Remove most content-level dependencies from TranslateManager.

chrome/browser/translate/translate_manager.cc

 // Copyright (c) 2012 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_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/common/url_constants.h"
-#include "components/translate/content/common/translate_messages.h"
 #include "components/translate/core/browser/language_state.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_browser_metrics.h"
 #include "components/translate/core/browser/translate_client.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_driver.h"
 #include "components/translate/core/browser/translate_error_details.h"
 #include "components/translate/core/browser/translate_language_list.h"
 #include "components/translate/core/browser/translate_prefs.h"
 #include "components/translate/core/browser/translate_script.h"
 #include "components/translate/core/browser/translate_url_util.h"
 #include "components/translate/core/common/language_detection_details.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_pref_names.h"
 #include "components/translate/core/common/translate_switches.h"
-#include "content/public/browser/navigation_controller.h"
-#include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 
-using content::NavigationController;
-using content::NavigationEntry;
 using content::WebContents;
 
 namespace {
 
 // Callbacks for translate errors.
 TranslateManager::TranslateErrorCallbackList* g_callback_list_ = NULL;
 
 const char kReportLanguageDetectionErrorURL[] =
     "https://translate.google.com/translate_error?client=cr&action=langidc";
 
@@ skipping 59 matching lines @@
   // automated browser testing.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           translate::switches::kDisableTranslate)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_SWITCH);
     return;
   }
 
   // MHTML pages currently cannot be translated.
   // See bug: 217945.
-  WebContents* web_contents = translate_tab_helper_->GetWebContents();
-  if (web_contents->GetContentsMimeType() == "multipart/related") {
+  if (translate_driver_->GetContentsMimeType() == "multipart/related") {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_MIME_TYPE_IS_NOT_SUPPORTED);
     return;
   }
 
   // Don't translate any Chrome specific page, e.g., New Tab Page, Download,
   // History, and so on.
-  GURL page_url = web_contents->GetURL();
+  const GURL& page_url = translate_driver_->GetVisibleURL();
   if (!translate_client_->IsTranslatableURL(page_url)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_URL_IS_NOT_SUPPORTED);
     return;
   }
 
   // Get the accepted languages list.
   std::vector<std::string> accept_languages_list;
   base::SplitString(prefs->GetString(accept_languages_pref_name_.c_str()), ',',
                     &accept_languages_list);
@@ skipping 70 matching lines @@
   translate_client_->ShowTranslateUI(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
                                      language_code,
                                      target_lang,
                                      TranslateErrors::NONE,
                                      false);
 }
 
 void TranslateManager::TranslatePage(const std::string& original_source_lang,
                                      const std::string& target_lang,
                                      bool triggered_from_menu) {
-  WebContents* web_contents = translate_tab_helper_->GetWebContents();
-  DCHECK(web_contents);
-  NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
-  if (!entry) {
+  if (!translate_driver_->HasCurrentPage()) {
     NOTREACHED();
     return;
   }
 
   // Translation can be kicked by context menu against unsupported languages.
   // Unsupported language strings should be replaced with
   // kUnknownLanguageCode in order to send a translation request with enabling
   // server side auto language detection.
   std::string source_lang(original_source_lang);
   if (!TranslateDownloadManager::IsSupportedLanguage(source_lang))
@@ skipping 12 matching lines @@
   if (!script_data.empty()) {
     DoTranslatePage(script_data, source_lang, target_lang);
     return;
   }
 
   // The script is not available yet.  Queue that request and query for the
   // script.  Once it is downloaded we'll do the translate.
   TranslateScript::RequestCallback callback =
       base::Bind(&TranslateManager::OnTranslateScriptFetchComplete,
                  weak_method_factory_.GetWeakPtr(),
-                 entry->GetPageID(),
+                 translate_driver_->GetCurrentPageID(),
                  source_lang,
                  target_lang);
 
   script->Request(callback);
 }
 
 void TranslateManager::RevertTranslation() {
   translate_driver_->RevertTranslation();
   translate_driver_->GetLanguageState().SetCurrentLanguage(
       translate_driver_->GetLanguageState().original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError() {
   TranslateBrowserMetrics::ReportLanguageDetectionError();
   // We'll open the URL in a new tab so that the user can tell us more.
   WebContents* web_contents = translate_tab_helper_->GetWebContents();
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
   if (!browser) {
     NOTREACHED();
     return;
   }
 
   GURL report_error_url = GURL(kReportLanguageDetectionErrorURL);
 
-  GURL page_url = web_contents->GetController().GetActiveEntry()->GetURL();
-  report_error_url = net::AppendQueryParameter(
-      report_error_url,
-      kUrlQueryName,
-      page_url.spec());
+  report_error_url =
+      net::AppendQueryParameter(report_error_url,
+                                kUrlQueryName,
+                                translate_driver_->GetActiveURL().spec());

[droger, 2014/04/08 12:01:28]

I'm sure you know this is related to http://crbug.com/360020.
We'll probably change this code in the near future, but I guess there is no harm
in doing this simple change here.

[blundell, 2014/04/08 12:46:02]

I was planning on leaving this code in TranslateManager, having the
TranslateManager and fully construct the report error URL and then pass it to
the client to present to the user. Does that make sense?

On 2014/04/08 12:01:28, droger wrote:

[droger, 2014/04/08 13:01:21]

I think this is fine, yes. Initially I had another idea (outlined in the bug),
but it's actually maybe not very good because we'd hit the problem again when
componentizing translate infobars.

 
   report_error_url = net::AppendQueryParameter(
       report_error_url,
       kSourceLanguageQueryName,
       translate_driver_->GetLanguageState().original_language());
 
   report_error_url = TranslateURLUtil::AddHostLocaleToUrl(report_error_url);
   report_error_url = TranslateURLUtil::AddApiKeyToUrl(report_error_url);
 
   chrome::AddSelectedTabWithURL(browser, report_error_url,
@@ skipping 18 matching lines @@
       !TranslateDownloadManager::IsSupportedLanguage(source_lang)) {
     error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
   translate_client_->ShowTranslateUI(translate::TRANSLATE_STEP_AFTER_TRANSLATE,
                                      source_lang,
                                      target_lang,
                                      error_type,
                                      false);
 
-  WebContents* web_contents = translate_tab_helper_->GetWebContents();
   if (error_type != TranslateErrors::NONE &&
       !translate_driver_->IsOffTheRecord()) {
     TranslateErrorDetails error_details;
     error_details.time = base::Time::Now();
-    error_details.url = web_contents->GetLastCommittedURL();
+    error_details.url = translate_driver_->GetLastCommittedURL();
     error_details.error = error_type;
     NotifyTranslateError(error_details);
   }
 }
 
 void TranslateManager::OnTranslateScriptFetchComplete(
     int page_id,
     const std::string& source_lang,
     const std::string& target_lang,
     bool success,
     const std::string& data) {
-  WebContents* web_contents = translate_tab_helper_->GetWebContents();
-  DCHECK(web_contents);
-  NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
-  if (!entry || entry->GetPageID() != page_id) {
+  if (!translate_driver_->HasCurrentPage() ||
+      translate_driver_->GetCurrentPageID() != page_id) {
     // We navigated away from the page the translation was triggered on.
     return;
   }
 
   if (success) {
     // Translate the page.
     TranslateScript* translate_script =
         TranslateDownloadManager::GetInstance()->script();
     DCHECK(translate_script);
     DoTranslatePage(translate_script->data(), source_lang, target_lang);
   } else {
     translate_client_->ShowTranslateUI(
         translate::TRANSLATE_STEP_TRANSLATE_ERROR,
         source_lang,
         target_lang,
         TranslateErrors::NETWORK,
         false);
     if (!translate_driver_->IsOffTheRecord()) {
       TranslateErrorDetails error_details;
       error_details.time = base::Time::Now();
-      error_details.url = entry->GetURL();
+      error_details.url = translate_driver_->GetActiveURL();
       error_details.error = TranslateErrors::NETWORK;
       NotifyTranslateError(error_details);
     }
   }
 }
 
 // static
 std::string TranslateManager::GetTargetLanguage(
     const std::vector<std::string>& accept_languages_list) {
   std::string ui_lang = TranslatePrefs::ConvertLangCodeForTranslation(
@@ skipping 26 matching lines @@
                                            &auto_target_lang)) {
     // We need to confirm that the saved target language is still supported.
     // Also, GetLanguageCode will take care of removing country code if any.
     auto_target_lang =
         TranslateDownloadManager::GetLanguageCode(auto_target_lang);
     if (TranslateDownloadManager::IsSupportedLanguage(auto_target_lang))
       return auto_target_lang;
   }
   return std::string();
 }