4th attempt at landing this.

It caused several tests to fails previously.
Cannot repro any of the failure. I am suspecting a clobber would have probably fixed it. (there is a change in one of the IPC messages that probably messed up the build somehow).
No code change.

Enabling language detection on page load.
A memory error has been fixed in the CLD library in the meantime.
This should hopefully fixes the crashers in the reliability tests.
Note that this version is actually simpler than the original review since the detection is now performed in the renderer. (So the CLD code runs sandboxed.)

Original review:
http://codereview.chromium.org/492024/show

BUG=30662
TEST=Run the unit-tests. 
TBR=brettw
Review URL: http://codereview.chromium.org/548057

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@36442 0039d316-1c4b-4281-b951-d872f2087c98

21 files changed, 227 insertions, 108 deletions

diff --git a/chrome/browser/browser.cc b/chrome/browser/browser.cc
index bcf74d1..7ccdaf5 100644
--- a/chrome/browser/browser.cc
+++ b/chrome/browser/browser.cc
@@ -1209,8 +1209,8 @@ void Browser::OpenCreateShortcutsDialog() {
   DCHECK(pending_web_app_action_ == NONE);
   pending_web_app_action_ = CREATE_SHORTCUT;
 
-  // Start fetching web app info for CreateApplicatoinShortcut dialog and
-  // show the dialog when the data is available in OnDidGetApplicationInfo.
+  // Start fetching web app info for CreateApplicationShortcut dialog and show
+  // the dialog when the data is available in OnDidGetApplicationInfo.
   current_tab->render_view_host()->GetApplicationInfo(entry->page_id());
 #else
   NOTIMPLEMENTED();
diff --git a/chrome/browser/browser_browsertest.cc b/chrome/browser/browser_browsertest.cc
index 756b7dc..a948947 100644
--- a/chrome/browser/browser_browsertest.cc
+++ b/chrome/browser/browser_browsertest.cc
@@ -288,3 +288,36 @@ IN_PROC_BROWSER_TEST_F(BrowserTest, FaviconOfOnloadRedirectToAnchorPage) {
       controller().GetActiveEntry();
   EXPECT_EQ(expected_favicon_url.spec(), entry->favicon().url().spec());
 }
+
+// The CLD library only works on Windows at this point.
+#if defined(OS_WIN)
+// Tests that the CLD (Compact Language Detection) works properly.
+IN_PROC_BROWSER_TEST_F(BrowserTest, PageLanguageDetection) {
+  static const wchar_t kDocRoot[] = L"chrome/test/data";
+  scoped_refptr<HTTPTestServer> server(
+        HTTPTestServer::CreateServer(kDocRoot, NULL));
+  ASSERT_TRUE(NULL != server.get());
+
+  TabContents* current_tab = browser()->GetSelectedTabContents();
+
+  // Navigate to a page in English.
+  ui_test_utils::NavigateToURL(
+      browser(), GURL(server->TestServerPage("files/english_page.html")));
+  NavigationEntry* entry = current_tab->controller().GetActiveEntry();
+  ASSERT_TRUE(NULL != entry);
+  EXPECT_TRUE(entry->language().empty());
+  std::string lang = ui_test_utils::WaitForLanguageDetection(current_tab);
+  EXPECT_EQ("en", lang);
+  EXPECT_EQ("en", entry->language());
+
+  // Now navigate to a page in French.
+  ui_test_utils::NavigateToURL(
+      browser(), GURL(server->TestServerPage("files/french_page.html")));
+  entry = current_tab->controller().GetActiveEntry();
+  ASSERT_TRUE(NULL != entry);
+  EXPECT_TRUE(entry->language().empty());
+  lang = ui_test_utils::WaitForLanguageDetection(current_tab);
+  EXPECT_EQ("fr", lang);
+  EXPECT_EQ("fr", entry->language());
+}
+#endif
diff --git a/chrome/browser/extensions/extension_tabs_module.cc b/chrome/browser/extensions/extension_tabs_module.cc
index 19d2687..fca5820 100644
--- a/chrome/browser/extensions/extension_tabs_module.cc
+++ b/chrome/browser/extensions/extension_tabs_module.cc
@@ -860,26 +860,49 @@ bool DetectTabLanguageFunction::RunImpl() {
       return false;
   }
 
-  // Figure out what language |contents| contains. This sends an async call via
-  // the browser to the renderer to determine the language of the tab the
-  // renderer has. The renderer sends back the language of the tab after the
-  // tab loads (it may be delayed) to the browser, which in turn notifies this
-  // object that the language has been received.
-  contents->GetPageLanguage();
+  AddRef();  // Balanced in GotLanguage()
+
+  NavigationEntry* entry = contents->controller().GetActiveEntry();
+  if (entry) {
+    std::string language = entry->language();
+    if (!language.empty()) {
+      // Delay the callback invocation until after the current JS call has
+      // returned.
+      MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
+          this, &DetectTabLanguageFunction::GotLanguage, language));
+      return true;
+    }
+  }
+  // The tab contents does not know its language yet.  Let's  wait until it
+  // receives it, or until the tab is closed/navigates to some other page.
   registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
                  Source<RenderViewHost>(contents->render_view_host()));
-  AddRef();  // balanced in Observe()
+  registrar_.Add(this, NotificationType::TAB_CLOSING,
+                 Source<NavigationController>(&(contents->controller())));
+  registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+                 Source<NavigationController>(&(contents->controller())));
   return true;
 }
 
 void DetectTabLanguageFunction::Observe(NotificationType type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
-  DCHECK(type == NotificationType::TAB_LANGUAGE_DETERMINED);
-  std::string language(*Details<std::string>(details).ptr());
+  std::string language;
+  if (type == NotificationType::TAB_LANGUAGE_DETERMINED)
+    language = *Details<std::string>(details).ptr();
+
+  registrar_.RemoveAll();
+
+  // Call GotLanguage in all cases as we want to guarantee the callback is
+  // called for every API call the extension made.
+  GotLanguage(language);
+}
+
+void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
-  Release();  // balanced in Run()
+
+  Release();  // Balanced in Run()
 }
 
 // static helpers
diff --git a/chrome/browser/extensions/extension_tabs_module.h b/chrome/browser/extensions/extension_tabs_module.h
index a4d6f5d..5282a17 100644
--- a/chrome/browser/extensions/extension_tabs_module.h
+++ b/chrome/browser/extensions/extension_tabs_module.h
@@ -133,6 +133,7 @@ class DetectTabLanguageFunction : public AsyncExtensionFunction,
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
+  void GotLanguage(const std::string& language);
   NotificationRegistrar registrar_;
   DECLARE_EXTENSION_FUNCTION_NAME("tabs.detectLanguage")
 };
diff --git a/chrome/browser/renderer_host/browser_render_process_host.cc b/chrome/browser/renderer_host/browser_render_process_host.cc
index 32c141c..dadeb53 100644
--- a/chrome/browser/renderer_host/browser_render_process_host.cc
+++ b/chrome/browser/renderer_host/browser_render_process_host.cc
@@ -738,7 +738,6 @@ void BrowserRenderProcessHost::OnMessageReceived(const IPC::Message& msg) {
     // Dispatch control messages.
     bool msg_is_ok = true;
     IPC_BEGIN_MESSAGE_MAP_EX(BrowserRenderProcessHost, msg, msg_is_ok)
-      IPC_MESSAGE_HANDLER(ViewHostMsg_PageContents, OnPageContents)
       IPC_MESSAGE_HANDLER(ViewHostMsg_UpdatedCacheStats,
                           OnUpdatedCacheStats)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SuddenTerminationChanged,
@@ -836,18 +835,6 @@ void BrowserRenderProcessHost::OnChannelError() {
   // TODO(darin): clean this up
 }
 
-void BrowserRenderProcessHost::OnPageContents(const GURL& url,
-                                              int32 page_id,
-                                              const std::wstring& contents) {
-  Profile* p = profile();
-  if (!p || p->IsOffTheRecord())
-    return;
-
-  HistoryService* hs = p->GetHistoryService(Profile::IMPLICIT_ACCESS);
-  if (hs)
-    hs->SetPageContents(url, contents);
-}
-
 void BrowserRenderProcessHost::OnUpdatedCacheStats(
     const WebCache::UsageStats& stats) {
   WebCacheManager::GetInstance()->ObserveStats(id(), stats);
diff --git a/chrome/browser/renderer_host/browser_render_process_host.h b/chrome/browser/renderer_host/browser_render_process_host.h
index 3a6e83b..0fd51ea 100644
--- a/chrome/browser/renderer_host/browser_render_process_host.h
+++ b/chrome/browser/renderer_host/browser_render_process_host.h
@@ -104,8 +104,6 @@ class BrowserRenderProcessHost : public RenderProcessHost,
   friend class VisitRelayingRenderProcessHost;
 
   // Control message handlers.
-  void OnPageContents(const GURL& url, int32 page_id,
-                      const std::wstring& contents);
   void OnUpdatedCacheStats(const WebKit::WebCache::UsageStats& stats);
   void SuddenTerminationChanged(bool enabled);
   void OnExtensionAddListener(const std::string& event_name);
diff --git a/chrome/browser/renderer_host/render_view_host.cc b/chrome/browser/renderer_host/render_view_host.cc
index 9a6c128..3d705cb 100644
--- a/chrome/browser/renderer_host/render_view_host.cc
+++ b/chrome/browser/renderer_host/render_view_host.cc
@@ -428,10 +428,6 @@ void RenderViewHost::StopFinding(bool clear_selection) {
   Send(new ViewMsg_StopFinding(routing_id(), clear_selection));
 }
 
-void RenderViewHost::GetPageLanguage() {
-  Send(new ViewMsg_DeterminePageLanguage(routing_id()));
-}
-
 void RenderViewHost::Zoom(PageZoom::Function function) {
   Send(new ViewMsg_Zoom(routing_id(), function));
 }
@@ -769,8 +765,6 @@ void RenderViewHost::OnMessageReceived(const IPC::Message& msg) {
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidFailProvisionalLoadWithError,
                         OnMsgDidFailProvisionalLoadWithError)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Find_Reply, OnMsgFindReply)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_PageLanguageDetermined,
-                        OnPageLanguageDetermined)
     IPC_MESSAGE_HANDLER(ViewMsg_ExecuteCodeFinished,
                         OnExecuteCodeFinished)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateFavIconURL, OnMsgUpdateFavIconURL)
@@ -854,6 +848,7 @@ void RenderViewHost::OnMessageReceived(const IPC::Message& msg) {
     IPC_MESSAGE_HANDLER(ViewHostMsg_AccessibilityFocusChange,
                         OnAccessibilityFocusChange)
     IPC_MESSAGE_HANDLER(ViewHostMsg_OnCSSInserted, OnCSSInserted)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_PageContents, OnPageContents)
     // Have the super handle all other messages.
     IPC_MESSAGE_UNHANDLED(RenderWidgetHost::OnMessageReceived(msg))
   IPC_END_MESSAGE_MAP_EX()
@@ -1167,14 +1162,6 @@ void RenderViewHost::OnMsgFindReply(int request_id,
   Send(new ViewMsg_FindReplyACK(routing_id()));
 }
 
-void RenderViewHost::OnPageLanguageDetermined(const std::string& language) {
-  std::string lang(language);
-  NotificationService::current()->Notify(
-      NotificationType::TAB_LANGUAGE_DETERMINED,
-      Source<RenderViewHost>(this),
-      Details<std::string>(&lang));
-}
-
 void RenderViewHost::OnExecuteCodeFinished(int request_id, bool success) {
   std::pair<int, bool> result_details(request_id, success);
   NotificationService::current()->Notify(
@@ -1810,3 +1797,15 @@ void RenderViewHost::OnAccessibilityFocusChange(int acc_obj_id) {
 void RenderViewHost::OnCSSInserted() {
   delegate_->DidInsertCSS();
 }
+
+void RenderViewHost::OnPageContents(const GURL& url,
+                                    int32 page_id,
+                                    const std::wstring& contents,
+                                    const std::string& language) {
+  RenderViewHostDelegate::BrowserIntegration* integration_delegate =
+      delegate_->GetBrowserIntegrationDelegate();
+  if (!integration_delegate)
+    return;
+  integration_delegate->OnPageContents(url, process()->id(), page_id, contents,
+                                       language);
+}
diff --git a/chrome/browser/renderer_host/render_view_host.h b/chrome/browser/renderer_host/render_view_host.h
index 8dcec74..b09cf7c 100644
--- a/chrome/browser/renderer_host/render_view_host.h
+++ b/chrome/browser/renderer_host/render_view_host.h
@@ -213,12 +213,6 @@ class RenderViewHost : public RenderWidgetHost,
   // clear the selection on the focused frame.
   void StopFinding(bool clear_selection);
 
-  // Gets the most probable language of the text content in the tab. (This sends
-  // a message to the render view.)  The caller gets the language via the
-  // NotificationService by registering to the
-  // NotificationType TAB_LANGUAGE_DETERMINED.
-  void GetPageLanguage();
-
   // Change the zoom level of a page.
   void Zoom(PageZoom::Function function);
 
@@ -428,22 +422,22 @@ class RenderViewHost : public RenderWidgetHost,
   // Creates a new RenderWidget with the given route id.
   void CreateNewWidget(int route_id, bool activatable);
 
-  // Send the response to an extension api call.
+  // Sends the response to an extension api call.
   void SendExtensionResponse(int request_id, bool success,
                              const std::string& response,
                              const std::string& error);
 
-  // Send a response to an extension api call that it was blocked for lack of
+  // Sends a response to an extension api call that it was blocked for lack of
   // permission.
   void BlockExtensionRequest(int request_id);
 
-  // Notify the renderer that its view type has changed.
+  // Notifies the renderer that its view type has changed.
   void ViewTypeChanged(ViewType::Type type);
 
-  // Tell renderer which browser window it is being attached to.
+  // Tells the renderer which browser window it is being attached to.
   void UpdateBrowserWindowId(int window_id);
 
-  // Tell render view that custom context action has been selected.
+  // Tells the render view that a custom context action has been selected.
   void PerformCustomContextMenuAction(unsigned action);
 
  protected:
@@ -501,7 +495,6 @@ class RenderViewHost : public RenderWidgetHost,
                       const gfx::Rect& selection_rect,
                       int active_match_ordinal,
                       bool final_update);
-  void OnPageLanguageDetermined(const std::string& language);
   void OnExecuteCodeFinished(int request_id, bool success);
   void OnMsgUpdateFavIconURL(int32 page_id, const GURL& icon_url);
   void OnMsgDidDownloadFavIcon(int id,
@@ -599,6 +592,10 @@ class RenderViewHost : public RenderWidgetHost,
   void OnExtensionPostMessage(int port_id, const std::string& message);
   void OnAccessibilityFocusChange(int acc_obj_id);
   void OnCSSInserted();
+  void OnPageContents(const GURL& url,
+                      int32 page_id,
+                      const std::wstring& contents,
+                      const std::string& language);
 
  private:
   friend class TestRenderViewHost;
diff --git a/chrome/browser/renderer_host/render_view_host_delegate.h b/chrome/browser/renderer_host/render_view_host_delegate.h
index 411840a..205c2d0 100644
--- a/chrome/browser/renderer_host/render_view_host_delegate.h
+++ b/chrome/browser/renderer_host/render_view_host_delegate.h
@@ -217,6 +217,13 @@ class RenderViewHostDelegate {
     virtual void OnDidGetApplicationInfo(
         int32 page_id,
         const webkit_glue::WebApplicationInfo& app_info) = 0;
+
+    // Notification that the contents of the page has been loaded.
+    virtual void OnPageContents(const GURL& url,
+                                int renderer_process_id,
+                                int32 page_id,
+                                const std::wstring& contents,
+                                const std::string& language) = 0;
   };
 
   // Resource ------------------------------------------------------------------
diff --git a/chrome/browser/tab_contents/navigation_entry.h b/chrome/browser/tab_contents/navigation_entry.h
index e679c10..df6ad06 100644
--- a/chrome/browser/tab_contents/navigation_entry.h
+++ b/chrome/browser/tab_contents/navigation_entry.h
@@ -389,6 +389,15 @@ class NavigationEntry {
     return restore_type_;
   }
 
+  // The ISO 639-1 language code (ex: en, fr, zh...) for the page.
+  // Can be empty if the language was not detected yet or is unknown.
+  void set_language(const std::string& language) {
+    language_ = language;
+  }
+  std::string language() const {
+    return language_;
+  }
+
  private:
   // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
   // Session/Tab restore save portions of this class so that it can be recreated
@@ -413,6 +422,7 @@ class NavigationEntry {
   GURL user_typed_url_;
   bool has_post_data_;
   RestoreType restore_type_;
+  std::string language_;  // ISO 639-1 language code.
 
   // This is a cached version of the result of GetTitleForDisplay. It prevents
   // us from having to do URL formatting on the URL evey time the title is
diff --git a/chrome/browser/tab_contents/tab_contents.cc b/chrome/browser/tab_contents/tab_contents.cc
index fdfa5ab..f4bc6d4 100644
--- a/chrome/browser/tab_contents/tab_contents.cc
+++ b/chrome/browser/tab_contents/tab_contents.cc
@@ -1098,10 +1098,6 @@ void TabContents::StopFinding(bool clear_selection) {
   render_view_host()->StopFinding(clear_selection);
 }
 
-void TabContents::GetPageLanguage() {
-  render_view_host()->GetPageLanguage();
-}
-
 void TabContents::OnSavePage() {
   // If we can not save the page, try to download it.
   if (!SavePackage::IsSavableContents(contents_mime_type())) {
@@ -1760,6 +1756,39 @@ void TabContents::OnDidGetApplicationInfo(
     delegate()->OnDidGetApplicationInfo(this, page_id);
 }
 
+void TabContents::OnPageContents(const GURL& url,
+                                 int renderer_process_id,
+                                 int32 page_id,
+                                 const std::wstring& contents,
+                                 const std::string& language) {
+  // Don't index any https pages. People generally don't want their bank
+  // accounts, etc. indexed on their computer, especially since some of these
+  // things are not marked cachable.
+  // TODO(brettw) we may want to consider more elaborate heuristics such as
+  // the cachability of the page. We may also want to consider subframes (this
+  // test will still index subframes if the subframe is SSL).
+  if (!url.SchemeIsSecure()) {
+    Profile* p = profile();
+    if (p && !p->IsOffTheRecord()) {
+      HistoryService* hs = p->GetHistoryService(Profile::IMPLICIT_ACCESS);
+      if (hs)
+        hs->SetPageContents(url, contents);
+    }
+  }
+
+  NavigationEntry* entry = controller_.GetActiveEntry();
+  if (process()->id() == renderer_process_id &&
+      entry && entry->page_id() == page_id) {
+    entry->set_language(language);
+  }
+
+  std::string lang = language;
+  NotificationService::current()->Notify(
+      NotificationType::TAB_LANGUAGE_DETERMINED,
+      Source<RenderViewHost>(render_view_host()),
+      Details<std::string>(&lang));
+}
+
 void TabContents::DidStartProvisionalLoadForFrame(
     RenderViewHost* render_view_host,
     bool is_main_frame,
diff --git a/chrome/browser/tab_contents/tab_contents.h b/chrome/browser/tab_contents/tab_contents.h
index de1e3ab..1418684 100644
--- a/chrome/browser/tab_contents/tab_contents.h
+++ b/chrome/browser/tab_contents/tab_contents.h
@@ -538,9 +538,6 @@ class TabContents : public PageNavigator,
     return last_search_result_;
   }
 
-  // Get the most probable language of the text content in the tab.
-  void GetPageLanguage();
-
   // Misc state & callbacks ----------------------------------------------------
 
   // Set whether the contents should block javascript message boxes or not.
@@ -814,6 +811,11 @@ class TabContents : public PageNavigator,
   virtual void OnDidGetApplicationInfo(
       int32 page_id,
       const webkit_glue::WebApplicationInfo& info);
+  virtual void OnPageContents(const GURL& url,
+                              int renderer_process_id,
+                              int32 page_id,
+                              const std::wstring& contents,
+                              const std::string& language);
 
   // RenderViewHostDelegate::Resource implementation.
   virtual void DidStartProvisionalLoadForFrame(RenderViewHost* render_view_host,
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 804b539..b65157c 100755
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -2121,12 +2121,10 @@
           ],
           'include_dirs': [
             'third_party/wtl/include',
-            '../third_party/cld',
           ],
           'dependencies': [
             '../gears/gears.gyp:gears',
             '../google_update/google_update.gyp:google_update',
-            '../third_party/cld/cld.gyp:cld',
             '../views/views.gyp:views',
             'installer/installer.gyp:installer_util',
             '<(allocator_target)',
diff --git a/chrome/common/notification_type.h b/chrome/common/notification_type.h
index d021059..d3f5640 100644
--- a/chrome/common/notification_type.h
+++ b/chrome/common/notification_type.h
@@ -223,8 +223,9 @@ class NotificationType {
     // is the InfoBubble.
     INFO_BUBBLE_CREATED,
 
-    // Sent after a call to RenderViewHost::DeterminePageLanguage. The details
-    // are Details<std::string> and the source is Source<RenderViewHost>.
+    // Sent when the language (English, French...) for a page has been detected.
+    // The details Details<std::string> contain the ISO 639-1 language code and
+    // the source is Source<RenderViewHost>.
     TAB_LANGUAGE_DETERMINED,
 
     // Sent after the renderer returns a snapshot of tab contents.
diff --git a/chrome/common/render_messages_internal.h b/chrome/common/render_messages_internal.h
index 1b984fe..d99914f 100644
--- a/chrome/common/render_messages_internal.h
+++ b/chrome/common/render_messages_internal.h
@@ -256,9 +256,6 @@ IPC_BEGIN_MESSAGES(View)
                       string16 /* search_text */,
                       WebKit::WebFindOptions)
 
-  // Asks the renderer for the language of the current page.
-  IPC_MESSAGE_ROUTED0(ViewMsg_DeterminePageLanguage)
-
   // Send from the renderer to the browser to return the script running result.
   IPC_MESSAGE_ROUTED2(ViewMsg_ExecuteCodeFinished,
                       int, /* request id */
@@ -1128,7 +1125,7 @@ IPC_BEGIN_MESSAGES(ViewHost)
   IPC_MESSAGE_ROUTED1(ViewHostMsg_UpdateSpellingPanelWithMisspelledWord,
                       string16 /* the word to update the panel with */)
 
-  // Initiate a download based on user actions like 'ALT+click'.
+  // Initiates a download based on user actions like 'ALT+click'.
   IPC_MESSAGE_ROUTED2(ViewHostMsg_DownloadUrl,
                       GURL /* url */,
                       GURL /* referrer */)
@@ -1146,9 +1143,12 @@ IPC_BEGIN_MESSAGES(ViewHost)
                              bool         /* out - success */,
                              std::wstring /* out - prompt field */)
 
-  // Sets the contents for the given page (URL and page ID are the first two
-  // arguments) given the contents that is the 3rd.
-  IPC_MESSAGE_CONTROL3(ViewHostMsg_PageContents, GURL, int32, std::wstring)
+  // Provides the contents for the given page that was loaded recently.
+  IPC_MESSAGE_ROUTED4(ViewHostMsg_PageContents,
+                      GURL         /* URL of the page */,
+                      int32        /* page id */,
+                      std::wstring /* page contents */,
+                      std::string  /* page ISO639_1 language code */)
 
   // Used to get the extension message bundle.
   IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetExtensionMessageBundle,
@@ -1177,13 +1177,13 @@ IPC_BEGIN_MESSAGES(ViewHost)
   // user right clicked.
   IPC_MESSAGE_ROUTED1(ViewHostMsg_ContextMenu, ContextMenuParams)
 
-  // Request that the given URL be opened in the specified manner.
+  // Requests that the given URL be opened in the specified manner.
   IPC_MESSAGE_ROUTED3(ViewHostMsg_OpenURL,
                       GURL /* url */,
                       GURL /* referrer */,
                       WindowOpenDisposition /* disposition */)
 
-  // Notify that the preferred size of the content changed.
+  // Notifies that the preferred size of the content changed.
   IPC_MESSAGE_ROUTED1(ViewHostMsg_DidContentsPreferredSizeChange,
                       gfx::Size /* pref_size */)
 
diff --git a/chrome/renderer/render_view.cc b/chrome/renderer/render_view.cc
index 649542f..a43c011 100644
--- a/chrome/renderer/render_view.cc
+++ b/chrome/renderer/render_view.cc
@@ -304,7 +304,6 @@ RenderView::RenderView(RenderThreadBase* render_thread,
       send_preferred_size_changes_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           notification_provider_(new NotificationProvider(this))),
-      determine_page_text_after_loading_stops_(false),
       view_type_(ViewType::INVALID),
       browser_window_id_(-1),
       last_top_level_navigation_page_id_(-1),
@@ -495,7 +494,6 @@ void RenderView::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(ViewMsg_CopyImageAt, OnCopyImageAt)
     IPC_MESSAGE_HANDLER(ViewMsg_ExecuteEditCommand, OnExecuteEditCommand)
     IPC_MESSAGE_HANDLER(ViewMsg_Find, OnFind)
-    IPC_MESSAGE_HANDLER(ViewMsg_DeterminePageLanguage, OnDeterminePageLanguage)
     IPC_MESSAGE_HANDLER(ViewMsg_Zoom, OnZoom)
     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForLoadingHost,
                         OnSetZoomLevelForLoadingHost)
@@ -666,24 +664,35 @@ void RenderView::CapturePageInfo(int load_id, bool preliminary_capture) {
   if (!preliminary_capture)
     last_indexed_page_id_ = load_id;
 
-  // get the URL for this page
+  // Get the URL for this page.
   GURL url(main_frame->url());
   if (url.is_empty())
     return;
 
-  // full text
+  // Retrieve the frame's full text.
   std::wstring contents;
   CaptureText(main_frame, &contents);
   if (contents.size()) {
-    // Send the text to the browser for indexing.
-    Send(new ViewHostMsg_PageContents(url, load_id, contents));
-  }
+    std::string language = "unknown";
+#if defined(OS_WIN)
+    int num_languages = 0;
+    bool is_reliable = false;
+    base::TimeTicks begin_time = base::TimeTicks::Now();
+    Language cld_lang =
+        DetectLanguageOfUnicodeText(NULL, contents.c_str(), true,
+                                    &is_reliable, &num_languages, NULL);
+    if (cld_lang != NUM_LANGUAGES && cld_lang != UNKNOWN_LANGUAGE &&
+        cld_lang != TG_UNKNOWN_LANGUAGE) {
+      language = LanguageCodeISO639_1(cld_lang);
+    }
+    UMA_HISTOGRAM_MEDIUM_TIMES("Renderer4.LanguageDetection",
+                               base::TimeTicks::Now() - begin_time);
+#endif
 
-  // Now that we have the contents, we can determine the language if necessary.
-  if (determine_page_text_after_loading_stops_) {
-    determine_page_text_after_loading_stops_ = false;
-    Send(new ViewHostMsg_PageLanguageDetermined(
-        routing_id_, DetermineTextLanguage(contents)));
+    // Send the text to the browser for indexing (the browser might decide not
+    // to index, if the URL is HTTPS for instance) and language discovery.
+    Send(new ViewHostMsg_PageContents(routing_id_, url, load_id, contents,
+                                      language));
   }
 
   // thumbnail
@@ -695,15 +704,6 @@ void RenderView::CaptureText(WebFrame* frame, std::wstring* contents) {
   if (!frame)
     return;
 
-  // Don't index any https pages. People generally don't want their bank
-  // accounts, etc. indexed on their computer, especially since some of these
-  // things are not marked cachable.
-  // TODO(brettw) we may want to consider more elaborate heuristics such as
-  // the cachability of the page. We may also want to consider subframes (this
-  // test will still index subframes if the subframe is SSL).
-  if (GURL(frame->url()).SchemeIsSecure())
-    return;
-
 #ifdef TIME_TEXT_RETRIEVAL
   double begin = time_util::GetHighResolutionTimeNow();
 #endif
@@ -3067,17 +3067,6 @@ void RenderView::OnFind(int request_id, const string16& search_text,
   }
 }
 
-void RenderView::OnDeterminePageLanguage() {
-  if (is_loading_) {
-    // Wait for the page to finish loading before trying to determine the
-    // language.
-    determine_page_text_after_loading_stops_ = true;
-    return;
-  }
-
-  Send(new ViewHostMsg_PageLanguageDetermined(routing_id_, DetectLanguage()));
-}
-
 std::string RenderView::DetectLanguage() {
   if (!webview() || is_loading_)
     return kUnknownLanguageCode;
diff --git a/chrome/renderer/render_view.h b/chrome/renderer/render_view.h
index 4d3a4e9..3e178ce 100644
--- a/chrome/renderer/render_view.h
+++ b/chrome/renderer/render_view.h
@@ -956,9 +956,6 @@ class RenderView : public RenderWidget,
   // Hopds a reference to the service which provides desktop notifications.
   scoped_ptr<NotificationProvider> notification_provider_;
 
-  // Set to true if request for capturing page text has been made.
-  bool determine_page_text_after_loading_stops_;
-
   // Holds state pertaining to a navigation that we initiated.  This is held by
   // the WebDataSource::ExtraData attribute.  We use pending_navigation_state_
   // as a temporary holder for the state until the WebDataSource corresponding
diff --git a/chrome/test/data/english_page.html b/chrome/test/data/english_page.html
new file mode 100644
index 0000000..539920d
--- /dev/null
+++ b/chrome/test/data/english_page.html
@@ -0,0 +1,6 @@
+<html>
+<head><title>This page is in English</title></head>
+<body>
+No joke! This is a page written in English. Awesome don't you think?
+</body>
+</html>
diff --git a/chrome/test/data/french_page.html b/chrome/test/data/french_page.html
new file mode 100644
index 0000000..7fcf684
--- /dev/null
+++ b/chrome/test/data/french_page.html
@@ -0,0 +1,6 @@
+<html>
+<head><title>Cette page est en Français</title></head>
+<body>
+Cette page a été rédigée en français. Saviez-vous que le Français est la langue officielle des jeux olympiques? Ça vous en bouche un coin, pas vrai?
+</body>
+</html>
diff --git a/chrome/test/ui_test_utils.cc b/chrome/test/ui_test_utils.cc
index add23d5..4bb031e 100644
--- a/chrome/test/ui_test_utils.cc
+++ b/chrome/test/ui_test_utils.cc
@@ -255,6 +255,33 @@ class SimpleNotificationObserver : public NotificationObserver {
   DISALLOW_COPY_AND_ASSIGN(SimpleNotificationObserver);
 };
 
+class LanguageDetectionNotificationObserver : public NotificationObserver {
+ public:
+  explicit LanguageDetectionNotificationObserver(
+      RenderViewHost* render_view_host) {
+    registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
+                  Source<RenderViewHost>(render_view_host));
+    ui_test_utils::RunMessageLoop();
+  }
+
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) {
+    language_ = *(Details<std::string>(details).ptr());
+    MessageLoopForUI::current()->Quit();
+  }
+
+  std::string language() const {
+    return language_;
+  }
+
+ private:
+  NotificationRegistrar registrar_;
+  std::string language_;
+
+  DISALLOW_COPY_AND_ASSIGN(LanguageDetectionNotificationObserver);
+};
+
 class FindInPageNotificationObserver : public NotificationObserver {
  public:
   explicit FindInPageNotificationObserver(TabContents* parent_tab)
@@ -485,6 +512,11 @@ void WaitForFocusInBrowser(Browser* browser) {
       browser);
 }
 
+std::string WaitForLanguageDetection(TabContents* tab) {
+  LanguageDetectionNotificationObserver observer(tab->render_view_host());
+  return observer.language();
+}
+
 int FindInPage(TabContents* tab_contents, const string16& search_string,
                bool forward, bool match_case, int* ordinal) {
   tab_contents->StartFinding(search_string, forward, match_case);
diff --git a/chrome/test/ui_test_utils.h b/chrome/test/ui_test_utils.h
index 89dc8fc..2c4cd95 100644
--- a/chrome/test/ui_test_utils.h
+++ b/chrome/test/ui_test_utils.h
@@ -115,6 +115,10 @@ void WaitForFocusChange(RenderViewHost* rvh);
 // traversal).
 void WaitForFocusInBrowser(Browser* browser);
 
+// Waits for the language of the page to have been detected and returns it.
+// This should be called right after a navigation notification was received.
+std::string WaitForLanguageDetection(TabContents* tab_contents);
+
 // Performs a find in the page of the specified tab. Returns the number of
 // matches found.  |ordinal| is an optional parameter which is set to the index
 // of the current match.