Move reload processing from TranslateManager to TranslateTabHelper.

chrome/browser/translate/translate_tab_helper.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/translate/translate_tab_helper.h"
 
 #include "base/logging.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/translate/translate_accept_languages_factory.h"
 #include "chrome/browser/translate/translate_infobar_delegate.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/translate/translate_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/translate/translate_bubble_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/translate/content/common/translate_messages.h"
 #include "components/translate/core/browser/page_translated_details.h"
 #include "components/translate/core/browser/translate_accept_languages.h"
+#include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_prefs.h"
 #include "components/translate/core/common/language_detection_details.h"
+#include "content/public/browser/navigation_details.h"
+#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
+#include "net/http/http_status_code.h"
 
 #if defined(CLD2_DYNAMIC_MODE)
 #include "base/files/file.h"
 #include "base/path_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #endif
 
+namespace {
+
+// The maximum number of attempts we'll do to see if the page has finshed
+// loading before giving up the translation
+const int kMaxTranslateLoadCheckAttempts = 20;
+
+}  // namespace
+
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(TranslateTabHelper);
 
 #if defined(CLD2_DYNAMIC_MODE)
 // Statics defined in the .h file:
 base::File* TranslateTabHelper::s_cached_file_ = NULL;
 uint64 TranslateTabHelper::s_cached_data_offset_ = 0;
 uint64 TranslateTabHelper::s_cached_data_length_ = 0;
 base::LazyInstance<base::Lock> TranslateTabHelper::s_file_lock_ =
     LAZY_INSTANCE_INITIALIZER;
 #endif
 
 TranslateTabHelper::TranslateTabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
-#if defined(CLD2_DYNAMIC_MODE)
-      weak_pointer_factory_(this),
-#endif
+      max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts),
       translate_driver_(&web_contents->GetController()),
-      translate_manager_(new TranslateManager(this, prefs::kAcceptLanguages)) {}
+      translate_manager_(new TranslateManager(this, prefs::kAcceptLanguages)),
+      weak_pointer_factory_(this) {}
 
 TranslateTabHelper::~TranslateTabHelper() {
 }
 
 LanguageState& TranslateTabHelper::GetLanguageState() {
   return translate_driver_.GetLanguageState();
 }
 
 // static
 scoped_ptr<TranslatePrefs> TranslateTabHelper::CreateTranslatePrefs(
@@ skipping 96 matching lines @@
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_PageTranslated, OnPageTranslated)
 #if defined(CLD2_DYNAMIC_MODE)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_NeedCLDData, OnCLDDataRequested)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
+void TranslateTabHelper::NavigationEntryCommitted(
+    const content::LoadCommittedDetails& load_details) {
+  // Check whether this is a reload: When doing a page reload, the

[blundell, 2014/04/07 08:03:01]

A couple notes here:

- The WCO method NavigationEntryCommitted() corresponds to the
NAV_ENTRY_COMMITTED notification, but is the currently-preferred mechanism.
- The logic here is simplified from what it previously was, as some of the
safety checks (e.g. that the WebContents in question isn't NULL) are no longer
necessary.

+  // TranslateLanguageDetermined IPC is not sent
+  // so the translation needs to be explicitly initiated.
+
+  content::NavigationEntry* entry =
+      web_contents()->GetController().GetActiveEntry();
+  if (!entry) {

[blundell, 2014/04/07 08:03:01]

I don't really know why there are all these checks sprinkled throughout the
translate code: it seems kind of bizarrely paranoid.

+    NOTREACHED();
+    return;
+  }
+
+  // If the navigation happened while offline don't show the translate
+  // bar since there will be nothing to translate.
+  if (load_details.http_status_code == 0 ||
+      load_details.http_status_code == net::HTTP_INTERNAL_SERVER_ERROR) {
+    return;
+  }
+
+  if (!load_details.is_main_frame &&
+      translate_driver_.GetLanguageState().translation_declined()) {
+    // Some sites (such as Google map) may trigger sub-frame navigations
+    // when the user interacts with the page.  We don't want to show a new
+    // infobar if the user already dismissed one in that case.
+    return;
+  }
+
+  // If not a reload, return.
+  if (entry->GetTransitionType() != content::PAGE_TRANSITION_RELOAD &&

[blundell, 2014/04/07 08:03:01]

I actually think it would be clearest if this check was the first one made, but
wanted to limit the diff from the previous version of this code for ease of
reviewing.

+      load_details.type != content::NAVIGATION_TYPE_SAME_PAGE) {
+    return;
+  }
+
+  if (!translate_driver_.GetLanguageState().page_needs_translation())
+    return;
+
+  // Note that we delay it as the ordering of the processing of this callback
+  // by WebContentsObservers is undefined and might result in the current
+  // infobars being removed. Since the translation initiation process might add
+  // an
+  // infobar, it must

[droger, 2014/04/07 11:14:41]

Nit: format.

+  // be done after that.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&TranslateTabHelper::InitiateTranslation,
+                 weak_pointer_factory_.GetWeakPtr(),
+                 translate_driver_.GetLanguageState().original_language(),
+                 0));
+}
+
 void TranslateTabHelper::DidNavigateAnyFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   // Let the LanguageState clear its state.
   translate_driver_.DidNavigate(details);
 }
 
 void TranslateTabHelper::WebContentsDestroyed(
     content::WebContents* web_contents) {
   // Translation process can be interrupted.
@@ skipping 122 matching lines @@
     } else {
       // Else, this request has taken care of it all. Cache all info.
       s_cached_file_ = file.release();
       s_cached_data_offset_ = data_offset;
       s_cached_data_length_ = data_length;
     }
   }
 }
 #endif // defined(CLD2_DYNAMIC_MODE)
 
+void TranslateTabHelper::InitiateTranslation(const std::string& page_lang,
+                                             int attempt) {
+  if (translate_driver_.GetLanguageState().translation_pending())
+    return;
+
+  // During a reload we need web content to be available before the
+  // translate script is executed. Otherwise we will run the translate script on
+  // an empty DOM which will fail. Therefore we wait a bit to see if the page
+  // has finished.
+  if (web_contents()->IsLoading() && attempt < max_reload_check_attempts_) {
+    int backoff = attempt * kMaxTranslateLoadCheckAttempts;
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&TranslateTabHelper::InitiateTranslation,
+                   weak_pointer_factory_.GetWeakPtr(),
+                   page_lang,
+                   ++attempt),
+        base::TimeDelta::FromMilliseconds(backoff));
+    return;
+  }
+
+  translate_manager_->InitiateTranslation(
+      TranslateDownloadManager::GetLanguageCode(page_lang));
+}
+
 void TranslateTabHelper::OnLanguageDetermined(
     const LanguageDetectionDetails& details,
     bool page_needs_translation) {
   translate_driver_.GetLanguageState().LanguageDetermined(
       details.adopted_language, page_needs_translation);
 
   if (web_contents())
     translate_manager_->InitiateTranslation(details.adopted_language);
 
   content::NotificationService::current()->Notify(
@@ skipping 52 matching lines @@
     if (GetLanguageState().InTranslateNavigation())
       return;
   }
 
   TranslateBubbleFactory::Show(
       browser->window(), web_contents(), step, error_type);
 #else
   NOTREACHED();
 #endif
 }