Move TranslateHelper to the translate component.

components/translate/content/renderer/translate_helper.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/renderer/translate/translate_helper.h"
+#include "components/translate/content/renderer/translate_helper.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/renderer/isolated_world_ids.h"
 #include "components/translate/content/common/translate_messages.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_metrics.h"
 #include "components/translate/core/common/translate_util.h"
 #include "components/translate/core/language_detection/language_detection_util.h"
 #include "content/public/common/content_constants.h"
+#include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
-#include "extensions/common/constants.h"
-#include "extensions/renderer/extension_groups.h"
 #include "ipc/ipc_platform_file.h"
-#include "content/public/common/url_constants.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebNodeList.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 #include "url/gurl.h"
 #include "v8/include/v8.h"
@@ skipping 28 matching lines @@
 const char kAutoDetectionLanguage[] = "auto";
 
 // Isolated world sets following content-security-policy.
 const char kContentSecurityPolicy[] = "script-src 'self' 'unsafe-eval'";
 
 // Whether or not we have set the CLD callback yet.
 bool g_cld_callback_set = false;
 
 }  // namespace
 
+namespace translate {
 
 ////////////////////////////////////////////////////////////////////////////////
 // TranslateHelper, public:
 //
-TranslateHelper::TranslateHelper(content::RenderView* render_view)
+TranslateHelper::TranslateHelper(content::RenderView* render_view,
+                                 int world_id,
+                                 int extension_group,
+                                 const std::string& extension_scheme)
     : content::RenderViewObserver(render_view),
       page_seq_no_(0),
       translation_pending_(false),
       cld_data_provider_(translate::CreateRendererCldDataProviderFor(this)),
       cld_data_polling_started_(false),
       cld_data_polling_canceled_(false),
       deferred_page_capture_(false),
       deferred_page_seq_no_(-1),
+      world_id_(world_id),
+      extension_group_(extension_group),
+      extension_scheme_(extension_scheme),
       weak_method_factory_(this) {
 }
 
 TranslateHelper::~TranslateHelper() {
   CancelPendingTranslation();
   CancelCldDataPolling();
 }
 
 void TranslateHelper::PrepareForUrl(const GURL& url) {
   ++page_seq_no_;
@@ skipping 10 matching lines @@
   // that fails that check. This will require moving unit tests and rewiring
   // other function calls as well, so for now replicate the logic here.
   if (url.is_empty())
     return;
   if (url.SchemeIs(content::kChromeUIScheme))
     return;
   if (url.SchemeIs(content::kChromeDevToolsScheme))
     return;
   if (url.SchemeIs(url::kFtpScheme))
     return;
-  if (url.SchemeIs(extensions::kExtensionScheme))
+  if (url.SchemeIs(extension_scheme_.c_str()))
     return;
 
   // Start polling for CLD data.
   cld_data_polling_started_ = true;
   TranslateHelper::SendCldDataRequest(0, 1000);
 }
 
 void TranslateHelper::PageCaptured(const base::string16& contents) {
   PageCapturedImpl(page_seq_no_, contents);
 }
@@ skipping 35 matching lines @@
   WebDocument document = main_frame->document();
   std::string content_language = document.contentLanguage().utf8();
   WebElement html_element = document.documentElement();
   std::string html_lang;
   // |html_element| can be null element, e.g. in
   // BrowserTest.WindowOpenClose.
   if (!html_element.isNull())
     html_lang = html_element.getAttribute("lang").utf8();
   std::string cld_language;
   bool is_cld_reliable;
-  std::string language = translate::DeterminePageLanguage(
+  std::string language = DeterminePageLanguage(
       content_language, html_lang, contents, &cld_language, &is_cld_reliable);
 
   if (language.empty())
     return;
 
   language_determined_time_ = base::TimeTicks::Now();
 
   GURL url(document.url());
-  translate::LanguageDetectionDetails details;
+  LanguageDetectionDetails details;
   details.time = base::Time::Now();
   details.url = url;
   details.content_language = content_language;
   details.cld_language = cld_language;
   details.is_cld_reliable = is_cld_reliable;
   details.html_root_language = html_lang;
   details.adopted_language = language;
 
   // TODO(hajimehoshi): If this affects performance, it should be set only if
   // translate-internals tab exists.
@@ skipping 53 matching lines @@
   return base::TimeDelta::FromMilliseconds(delayInMs);
 }
 
 void TranslateHelper::ExecuteScript(const std::string& script) {
   WebFrame* main_frame = GetMainFrame();
   if (!main_frame)
     return;
 
   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
   main_frame->executeScriptInIsolatedWorld(
-      chrome::ISOLATED_WORLD_ID_TRANSLATE,
-      &source,
-      1,
-      extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS);
+      world_id_, &source, 1, extension_group_);
 }
 
 bool TranslateHelper::ExecuteScriptAndGetBoolResult(const std::string& script,
                                                     bool fallback) {
   WebFrame* main_frame = GetMainFrame();
   if (!main_frame)
     return fallback;
 
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   WebVector<v8::Local<v8::Value> > results;
   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
   main_frame->executeScriptInIsolatedWorld(
-      chrome::ISOLATED_WORLD_ID_TRANSLATE,
-      &source,
-      1,
-      extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS,
-      &results);
+      world_id_, &source, 1, extension_group_, &results);
   if (results.size() != 1 || results[0].IsEmpty() || !results[0]->IsBoolean()) {
     NOTREACHED();
     return fallback;
   }
 
   return results[0]->BooleanValue();
 }
 
 std::string TranslateHelper::ExecuteScriptAndGetStringResult(
     const std::string& script) {
   WebFrame* main_frame = GetMainFrame();
   if (!main_frame)
     return std::string();
 
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   WebVector<v8::Local<v8::Value> > results;
   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
   main_frame->executeScriptInIsolatedWorld(
-      chrome::ISOLATED_WORLD_ID_TRANSLATE,
-      &source,
-      1,
-      extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS,
-      &results);
+      world_id_, &source, 1, extension_group_, &results);
   if (results.size() != 1 || results[0].IsEmpty() || !results[0]->IsString()) {
     NOTREACHED();
     return std::string();
   }
 
   v8::Local<v8::String> v8_str = results[0]->ToString();
   int length = v8_str->Utf8Length() + 1;
   scoped_ptr<char[]> str(new char[length]);
   v8_str->WriteUtf8(str.get(), length);
   return std::string(str.get());
 }
 
 double TranslateHelper::ExecuteScriptAndGetDoubleResult(
     const std::string& script) {
   WebFrame* main_frame = GetMainFrame();
   if (!main_frame)
     return 0.0;
 
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   WebVector<v8::Local<v8::Value> > results;
   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
   main_frame->executeScriptInIsolatedWorld(
-      chrome::ISOLATED_WORLD_ID_TRANSLATE,
-      &source,
-      1,
-      extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS,
-      &results);
+      world_id_, &source, 1, extension_group_, &results);
   if (results.size() != 1 || results[0].IsEmpty() || !results[0]->IsNumber()) {
     NOTREACHED();
     return 0.0;
   }
 
   return results[0]->NumberValue();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TranslateHelper, private:
@@ skipping 62 matching lines @@
     return;
 
   // Any pending translation is now irrelevant.
   CancelPendingTranslation();
 
   // Set our states.
   translation_pending_ = true;
 
   // If the source language is undetermined, we'll let the translate element
   // detect it.
-  source_lang_ = (source_lang != translate::kUnknownLanguageCode) ?
-                  source_lang : kAutoDetectionLanguage;
+  source_lang_ = (source_lang != kUnknownLanguageCode) ? source_lang
+                                                       : kAutoDetectionLanguage;
   target_lang_ = target_lang;
 
-  translate::ReportUserActionDuration(language_determined_time_,
-                                      base::TimeTicks::Now());
+  ReportUserActionDuration(language_determined_time_, base::TimeTicks::Now());
 
   GURL url(main_frame->document().url());
-  translate::ReportPageScheme(url.scheme());
+  ReportPageScheme(url.scheme());
 
   // Set up v8 isolated world with proper content-security-policy and
   // security-origin.
   WebFrame* frame = GetMainFrame();
   if (frame) {
     frame->setIsolatedWorldContentSecurityPolicy(
-        chrome::ISOLATED_WORLD_ID_TRANSLATE,
-        WebString::fromUTF8(kContentSecurityPolicy));
+        world_id_, WebString::fromUTF8(kContentSecurityPolicy));
 
-    GURL security_origin = translate::GetTranslateSecurityOrigin();
+    GURL security_origin = GetTranslateSecurityOrigin();
     frame->setIsolatedWorldSecurityOrigin(
-        chrome::ISOLATED_WORLD_ID_TRANSLATE,
-        WebSecurityOrigin::create(security_origin));
+        world_id_, WebSecurityOrigin::create(security_origin));
   }
 
   if (!IsTranslateLibAvailable()) {
     // Evaluate the script to add the translation related method to the global
     // context of the page.
     ExecuteScript(translate_script);
     DCHECK(IsTranslateLibAvailable());
   }
 
   TranslatePageImpl(page_seq_no, 0);
@@ skipping 15 matching lines @@
 
 void TranslateHelper::CheckTranslateStatus(int page_seq_no) {
   // If this is not the same page, the translation has been canceled.  If the
   // view is gone, the page is closing.
   if (page_seq_no_ != page_seq_no || !render_view()->GetWebView())
     return;
 
   // First check if there was an error.
   if (HasTranslationFailed()) {
     // TODO(toyoshim): Check |errorCode| of translate.js and notify it here.
-    NotifyBrowserTranslationFailed(
-        translate::TranslateErrors::TRANSLATION_ERROR);
+    NotifyBrowserTranslationFailed(TranslateErrors::TRANSLATION_ERROR);
     return;  // There was an error.
   }
 
   if (HasTranslationFinished()) {
     std::string actual_source_lang;
     // Translation was successfull, if it was auto, retrieve the source
     // language the Translate Element detected.
     if (source_lang_ == kAutoDetectionLanguage) {
       actual_source_lang = GetOriginalPageLanguage();
       if (actual_source_lang.empty()) {
-        NotifyBrowserTranslationFailed(
-            translate::TranslateErrors::UNKNOWN_LANGUAGE);
+        NotifyBrowserTranslationFailed(TranslateErrors::UNKNOWN_LANGUAGE);
         return;
       } else if (actual_source_lang == target_lang_) {
-        NotifyBrowserTranslationFailed(
-            translate::TranslateErrors::IDENTICAL_LANGUAGES);
+        NotifyBrowserTranslationFailed(TranslateErrors::IDENTICAL_LANGUAGES);
         return;
       }
     } else {
       actual_source_lang = source_lang_;
     }
 
     if (!translation_pending_) {
       NOTREACHED();
       return;
     }
 
     translation_pending_ = false;
 
     // Check JavaScript performance counters for UMA reports.
-    translate::ReportTimeToTranslate(
+    ReportTimeToTranslate(
         ExecuteScriptAndGetDoubleResult("cr.googleTranslate.translationTime"));
 
     // Notify the browser we are done.
     render_view()->Send(
         new ChromeViewHostMsg_PageTranslated(render_view()->GetRoutingID(),
                                              actual_source_lang,
                                              target_lang_,
-                                             translate::TranslateErrors::NONE));
+                                             TranslateErrors::NONE));
     return;
   }
 
   // The translation is still pending, check again later.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TranslateHelper::CheckTranslateStatus,
                  weak_method_factory_.GetWeakPtr(), page_seq_no),
       AdjustDelay(kTranslateStatusCheckDelayMs));
 }
 
 void TranslateHelper::TranslatePageImpl(int page_seq_no, int count) {
   DCHECK_LT(count, kMaxTranslateInitCheckAttempts);
   if (page_seq_no_ != page_seq_no || !render_view()->GetWebView())
     return;
 
   if (!IsTranslateLibReady()) {
     // The library is not ready, try again later, unless we have tried several
     // times unsucessfully already.
     if (++count >= kMaxTranslateInitCheckAttempts) {
-      NotifyBrowserTranslationFailed(
-          translate::TranslateErrors::INITIALIZATION_ERROR);
+      NotifyBrowserTranslationFailed(TranslateErrors::INITIALIZATION_ERROR);
       return;
     }
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&TranslateHelper::TranslatePageImpl,
                    weak_method_factory_.GetWeakPtr(),
                    page_seq_no, count),
         AdjustDelay(count * kTranslateInitCheckDelayMs));
     return;
   }
 
   // The library is loaded, and ready for translation now.
   // Check JavaScript performance counters for UMA reports.
-  translate::ReportTimeToBeReady(
+  ReportTimeToBeReady(
       ExecuteScriptAndGetDoubleResult("cr.googleTranslate.readyTime"));
-  translate::ReportTimeToLoad(
+  ReportTimeToLoad(
       ExecuteScriptAndGetDoubleResult("cr.googleTranslate.loadTime"));
 
   if (!StartTranslation()) {
-    NotifyBrowserTranslationFailed(
-        translate::TranslateErrors::TRANSLATION_ERROR);
+    NotifyBrowserTranslationFailed(TranslateErrors::TRANSLATION_ERROR);
     return;
   }
   // Check the status of the translation.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TranslateHelper::CheckTranslateStatus,
                  weak_method_factory_.GetWeakPtr(), page_seq_no),
       AdjustDelay(kTranslateStatusCheckDelayMs));
 }
 
 void TranslateHelper::NotifyBrowserTranslationFailed(
-    translate::TranslateErrors::Type error) {
+    TranslateErrors::Type error) {
   translation_pending_ = false;
   // Notify the browser there was an error.
   render_view()->Send(new ChromeViewHostMsg_PageTranslated(
       render_view()->GetRoutingID(), source_lang_, target_lang_, error));
 }
 
 WebFrame* TranslateHelper::GetMainFrame() {
   WebView* web_view = render_view()->GetWebView();
 
   // When the tab is going to be closed, the web_view can be NULL.
@@ skipping 72 matching lines @@
   // be DEFERRED until CLD is ready. In the latter case, CLD is in dynamic mode
   // and may eventually become available, triggering the RESUMED event; after
   // this, everything should start being ON_TIME. This should never run more
   // than twice in a page load, under any conditions.
   // Also note that language detection is triggered off of a delay AFTER the
   // page load completed event has fired, making this very much off the critical
   // path.
   content::RenderThread::Get()->UpdateHistograms(
       content::kHistogramSynchronizerReservedSequenceNumber);
 }
+
+}  // namespace translate