Fix translate namespace

chrome/browser/translate/chrome_translate_client.cc

 // Copyright 2014 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/chrome_translate_client.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
@@ skipping 66 matching lines @@
 #endif
 
 }  // namespace
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(ChromeTranslateClient);
 
 ChromeTranslateClient::ChromeTranslateClient(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts),
       translate_driver_(&web_contents->GetController()),
-      translate_manager_(new TranslateManager(this, prefs::kAcceptLanguages)),
-      cld_data_provider_(translate::CreateBrowserCldDataProviderFor(
-          web_contents)),
+      translate_manager_(
+          new translate::TranslateManager(this, prefs::kAcceptLanguages)),
+      cld_data_provider_(
+          translate::CreateBrowserCldDataProviderFor(web_contents)),
       weak_pointer_factory_(this) {
 #if defined(CLD_DATA_FROM_STANDALONE)
   if (!g_cld_file_path_initialized_)
     InitCldFilePath();
 #endif
 }
 
 ChromeTranslateClient::~ChromeTranslateClient() {
 }
 
-LanguageState& ChromeTranslateClient::GetLanguageState() {
+translate::LanguageState& ChromeTranslateClient::GetLanguageState() {
   return translate_manager_->GetLanguageState();
 }
 
 // static
-scoped_ptr<TranslatePrefs> ChromeTranslateClient::CreateTranslatePrefs(
-    PrefService* prefs) {
+scoped_ptr<translate::TranslatePrefs>
+ChromeTranslateClient::CreateTranslatePrefs(PrefService* prefs) {
 #if defined(OS_CHROMEOS)
   const char* preferred_languages_prefs = prefs::kLanguagePreferredLanguages;
 #else
   const char* preferred_languages_prefs = NULL;
 #endif
-  return scoped_ptr<TranslatePrefs>(new TranslatePrefs(
+  return scoped_ptr<translate::TranslatePrefs>(new translate::TranslatePrefs(
       prefs, prefs::kAcceptLanguages, preferred_languages_prefs));
 }
 
 // static
-TranslateAcceptLanguages* ChromeTranslateClient::GetTranslateAcceptLanguages(
+translate::TranslateAcceptLanguages*
+ChromeTranslateClient::GetTranslateAcceptLanguages(
     content::BrowserContext* browser_context) {
   return TranslateAcceptLanguagesFactory::GetForBrowserContext(browser_context);
 }
 
 // static
-TranslateManager* ChromeTranslateClient::GetManagerFromWebContents(
+translate::TranslateManager* ChromeTranslateClient::GetManagerFromWebContents(
     content::WebContents* web_contents) {
   ChromeTranslateClient* chrome_translate_client =
       FromWebContents(web_contents);
   if (!chrome_translate_client)
     return NULL;
   return chrome_translate_client->GetTranslateManager();
 }
 
 // static
 void ChromeTranslateClient::GetTranslateLanguages(
     content::WebContents* web_contents,
     std::string* source,
     std::string* target) {
   DCHECK(source != NULL);
   DCHECK(target != NULL);
 
   ChromeTranslateClient* chrome_translate_client =
       FromWebContents(web_contents);
   if (!chrome_translate_client)
     return;
 
-  *source = TranslateDownloadManager::GetLanguageCode(
+  *source = translate::TranslateDownloadManager::GetLanguageCode(
       chrome_translate_client->GetLanguageState().original_language());
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   Profile* original_profile = profile->GetOriginalProfile();
   PrefService* prefs = original_profile->GetPrefs();
-  scoped_ptr<TranslatePrefs> translate_prefs = CreateTranslatePrefs(prefs);
+  scoped_ptr<translate::TranslatePrefs> translate_prefs =
+      CreateTranslatePrefs(prefs);
   if (!web_contents->GetBrowserContext()->IsOffTheRecord()) {
     std::string auto_translate_language =
-        TranslateManager::GetAutoTargetLanguage(*source, translate_prefs.get());
+        translate::TranslateManager::GetAutoTargetLanguage(
+            *source, translate_prefs.get());
     if (!auto_translate_language.empty()) {
       *target = auto_translate_language;
       return;
     }
   }
 
   std::string accept_languages_str = prefs->GetString(prefs::kAcceptLanguages);
   std::vector<std::string> accept_languages_list;
   base::SplitString(accept_languages_str, ',', &accept_languages_list);
-  *target = TranslateManager::GetTargetLanguage(accept_languages_list);
+  *target =
+      translate::TranslateManager::GetTargetLanguage(accept_languages_list);
 }
 
-TranslateManager* ChromeTranslateClient::GetTranslateManager() {
+translate::TranslateManager* ChromeTranslateClient::GetTranslateManager() {
   return translate_manager_.get();
 }
 
 content::WebContents* ChromeTranslateClient::GetWebContents() {
   return web_contents();
 }
 
-void ChromeTranslateClient::ShowTranslateUI(translate::TranslateStep step,
-                                            const std::string source_language,
-                                            const std::string target_language,
-                                            TranslateErrors::Type error_type,
-                                            bool triggered_from_menu) {
+void ChromeTranslateClient::ShowTranslateUI(
+    translate::TranslateStep step,
+    const std::string source_language,
+    const std::string target_language,
+    translate::TranslateErrors::Type error_type,
+    bool triggered_from_menu) {
   DCHECK(web_contents());
-  if (error_type != TranslateErrors::NONE)
+  if (error_type != translate::TranslateErrors::NONE)
     step = translate::TRANSLATE_STEP_TRANSLATE_ERROR;
 
   if (TranslateService::IsTranslateBubbleEnabled()) {
     // Bubble UI.
     if (step == translate::TRANSLATE_STEP_BEFORE_TRANSLATE) {
       // TODO(droger): Move this logic out of UI code.
       GetLanguageState().SetTranslateEnabled(true);
       if (!GetLanguageState().HasLanguageChanged())
         return;
 
       if (!triggered_from_menu) {
         if (web_contents()->GetBrowserContext()->IsOffTheRecord())
           return;
         if (GetTranslatePrefs()->IsTooOftenDenied())
           return;
       }
     }
     ShowBubble(step, error_type);
     return;
   }
 
   // Infobar UI.
-  TranslateInfoBarDelegate::Create(
+  translate::TranslateInfoBarDelegate::Create(
       step != translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
       translate_manager_->GetWeakPtr(),
       InfoBarService::FromWebContents(web_contents()),
       web_contents()->GetBrowserContext()->IsOffTheRecord(),
       step,
       source_language,
       target_language,
       error_type,
       triggered_from_menu);
 }
 
-TranslateDriver* ChromeTranslateClient::GetTranslateDriver() {
+translate::TranslateDriver* ChromeTranslateClient::GetTranslateDriver() {
   return &translate_driver_;
 }
 
 PrefService* ChromeTranslateClient::GetPrefs() {
   DCHECK(web_contents());
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   return profile->GetOriginalProfile()->GetPrefs();
 }
 
-scoped_ptr<TranslatePrefs> ChromeTranslateClient::GetTranslatePrefs() {
+scoped_ptr<translate::TranslatePrefs>
+ChromeTranslateClient::GetTranslatePrefs() {
   DCHECK(web_contents());
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   return CreateTranslatePrefs(profile->GetPrefs());
 }
 
-TranslateAcceptLanguages* ChromeTranslateClient::GetTranslateAcceptLanguages() {
+translate::TranslateAcceptLanguages*
+ChromeTranslateClient::GetTranslateAcceptLanguages() {
   DCHECK(web_contents());
   return GetTranslateAcceptLanguages(web_contents()->GetBrowserContext());
 }
 
 int ChromeTranslateClient::GetInfobarIconID() const {
   return IDR_INFOBAR_TRANSLATE;
 }
 
 // ChromeTranslateClient::CreateInfoBar() is implemented in platform-specific
 // files, except the TOOLKIT_VIEWS implementation, which has been removed.
 #if defined(TOOLKIT_VIEWS)
 scoped_ptr<infobars::InfoBar> ChromeTranslateClient::CreateInfoBar(
-    scoped_ptr<TranslateInfoBarDelegate> delegate) const {
+    scoped_ptr<translate::TranslateInfoBarDelegate> delegate) const {
   return scoped_ptr<infobars::InfoBar>();
 }
 #endif
 
 bool ChromeTranslateClient::IsTranslatableURL(const GURL& url) {
   return TranslateService::IsTranslatableURL(url);
 }
 
 void ChromeTranslateClient::ShowReportLanguageDetectionErrorUI(
     const GURL& report_url) {
@@ skipping 112 matching lines @@
         FROM_HERE,
         base::Bind(&ChromeTranslateClient::InitiateTranslation,
                    weak_pointer_factory_.GetWeakPtr(),
                    page_lang,
                    attempt + 1),
         base::TimeDelta::FromMilliseconds(backoff));
     return;
   }
 
   translate_manager_->InitiateTranslation(
-      TranslateDownloadManager::GetLanguageCode(page_lang));
+      translate::TranslateDownloadManager::GetLanguageCode(page_lang));
 }
 
 void ChromeTranslateClient::OnTranslateAssignedSequenceNumber(int page_seq_no) {
   translate_manager_->set_current_seq_no(page_seq_no);
 }
 
 void ChromeTranslateClient::OnLanguageDetermined(
-    const LanguageDetectionDetails& details,
+    const translate::LanguageDetectionDetails& details,
     bool page_needs_translation) {
   GetLanguageState().LanguageDetermined(details.adopted_language,
                                         page_needs_translation);
 
   if (web_contents())
     translate_manager_->InitiateTranslation(details.adopted_language);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
       content::Source<content::WebContents>(web_contents()),
-      content::Details<const LanguageDetectionDetails>(&details));
+      content::Details<const translate::LanguageDetectionDetails>(&details));
 }
 
-void ChromeTranslateClient::OnPageTranslated(const std::string& original_lang,
-                                             const std::string& translated_lang,
-                                             TranslateErrors::Type error_type) {
+void ChromeTranslateClient::OnPageTranslated(
+    const std::string& original_lang,
+    const std::string& translated_lang,
+    translate::TranslateErrors::Type error_type) {
   DCHECK(web_contents());
   translate_manager_->PageTranslated(
       original_lang, translated_lang, error_type);
 
-  PageTranslatedDetails details;
+  translate::PageTranslatedDetails details;
   details.source_language = original_lang;
   details.target_language = translated_lang;
   details.error_type = error_type;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PAGE_TRANSLATED,
       content::Source<content::WebContents>(web_contents()),
-      content::Details<PageTranslatedDetails>(&details));
+      content::Details<translate::PageTranslatedDetails>(&details));
 }
 
-void ChromeTranslateClient::ShowBubble(translate::TranslateStep step,
-                                       TranslateErrors::Type error_type) {
+void ChromeTranslateClient::ShowBubble(
+    translate::TranslateStep step,
+    translate::TranslateErrors::Type error_type) {
 // The bubble is implemented only on the desktop platforms.
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
 
   // |browser| might be NULL when testing. In this case, Show(...) should be
   // called because the implementation for testing is used.
   if (!browser) {
     TranslateBubbleFactory::Show(NULL, web_contents(), step, error_type);
     return;
   }
@@ skipping 17 matching lines @@
     if (GetLanguageState().InTranslateNavigation())
       return;
   }
 
   TranslateBubbleFactory::Show(
       browser->window(), web_contents(), step, error_type);
 #else
   NOTREACHED();
 #endif
 }