Fix translate namespace

chrome/renderer/translate/translate_helper_browsertest.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 "base/time/time.h"
 #include "chrome/renderer/translate/translate_helper.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/translate/content/common/translate_messages.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "content/public/renderer/render_view.h"
@@ skipping 49 matching lines @@
     translate_helper_ = new TestTranslateHelper(view_);
   }
 
   virtual void TearDown() OVERRIDE {
     delete translate_helper_;
     ChromeRenderViewTest::TearDown();
   }
 
   bool GetPageTranslatedMessage(std::string* original_lang,
                                 std::string* target_lang,
-                                TranslateErrors::Type* error) {
+                                translate::TranslateErrors::Type* error) {
     const IPC::Message* message = render_thread_->sink().
         GetUniqueMessageMatching(ChromeViewHostMsg_PageTranslated::ID);
     if (!message)
       return false;
-    Tuple3<std::string, std::string, TranslateErrors::Type> translate_param;
+    Tuple3<std::string, std::string, translate::TranslateErrors::Type>
+        translate_param;
     ChromeViewHostMsg_PageTranslated::Read(message, &translate_param);
     if (original_lang)
       *original_lang = translate_param.a;
     if (target_lang)
       *target_lang = translate_param.b;
     if (error)
       *error = translate_param.c;
     return true;
   }
 
@@ skipping 13 matching lines @@
       .WillRepeatedly(Return(true));
 
   EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
       .Times(AtLeast(5))  // See kMaxTranslateInitCheckAttempts in
                           // translate_helper.cc
       .WillRepeatedly(Return(false));
 
   translate_helper_->TranslatePage("en", "fr", std::string());
   base::MessageLoop::current()->RunUntilIdle();
 
-  TranslateErrors::Type error;
+  translate::TranslateErrors::Type error;
   ASSERT_TRUE(GetPageTranslatedMessage(NULL, NULL, &error));
-  EXPECT_EQ(TranslateErrors::INITIALIZATION_ERROR, error);
+  EXPECT_EQ(translate::TranslateErrors::INITIALIZATION_ERROR, error);
 }
 
 // Tests that the browser gets notified of the translation success when the
 // translation succeeds.
 TEST_F(TranslateHelperBrowserTest, TranslateSuccess) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
   EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
@@ skipping 16 matching lines @@
   EXPECT_CALL(*translate_helper_,
               ExecuteScriptAndGetDoubleResult(_)).Times(3);
 
   std::string original_lang("en");
   std::string target_lang("fr");
   translate_helper_->TranslatePage(original_lang, target_lang, std::string());
   base::MessageLoop::current()->RunUntilIdle();
 
   std::string received_original_lang;
   std::string received_target_lang;
-  TranslateErrors::Type error;
+  translate::TranslateErrors::Type error;
   ASSERT_TRUE(GetPageTranslatedMessage(&received_original_lang,
                                        &received_target_lang,
                                        &error));
   EXPECT_EQ(original_lang, received_original_lang);
   EXPECT_EQ(target_lang, received_target_lang);
-  EXPECT_EQ(TranslateErrors::NONE, error);
+  EXPECT_EQ(translate::TranslateErrors::NONE, error);
 }
 
 // Tests that the browser gets notified of the translation failure when the
 // translation fails.
 TEST_F(TranslateHelperBrowserTest, TranslateFailure) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
   EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
@@ skipping 14 matching lines @@
       .Times(AtLeast(1))
       .WillRepeatedly(Return(false));
 
   // V8 call for performance monitoring should be ignored.
   EXPECT_CALL(*translate_helper_,
               ExecuteScriptAndGetDoubleResult(_)).Times(2);
 
   translate_helper_->TranslatePage("en", "fr", std::string());
   base::MessageLoop::current()->RunUntilIdle();
 
-  TranslateErrors::Type error;
+  translate::TranslateErrors::Type error;
   ASSERT_TRUE(GetPageTranslatedMessage(NULL, NULL, &error));
-  EXPECT_EQ(TranslateErrors::TRANSLATION_ERROR, error);
+  EXPECT_EQ(translate::TranslateErrors::TRANSLATION_ERROR, error);
 }
 
 // Tests that when the browser translate a page for which the language is
 // undefined we query the translate element to get the language.
 TEST_F(TranslateHelperBrowserTest, UndefinedSourceLang) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
   EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
@@ skipping 13 matching lines @@
 
   // V8 call for performance monitoring should be ignored.
   EXPECT_CALL(*translate_helper_,
               ExecuteScriptAndGetDoubleResult(_)).Times(3);
 
   translate_helper_->TranslatePage(translate::kUnknownLanguageCode,
                                    "fr",
                                    std::string());
   base::MessageLoop::current()->RunUntilIdle();
 
-  TranslateErrors::Type error;
+  translate::TranslateErrors::Type error;
   std::string original_lang;
   std::string target_lang;
   ASSERT_TRUE(GetPageTranslatedMessage(&original_lang, &target_lang, &error));
   EXPECT_EQ("de", original_lang);
   EXPECT_EQ("fr", target_lang);
-  EXPECT_EQ(TranslateErrors::NONE, error);
+  EXPECT_EQ(translate::TranslateErrors::NONE, error);
 }
 
 // Tests that starting a translation while a similar one is pending does not
 // break anything.
 TEST_F(TranslateHelperBrowserTest, MultipleSimilarTranslations) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
   EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
@@ skipping 14 matching lines @@
   std::string original_lang("en");
   std::string target_lang("fr");
   translate_helper_->TranslatePage(original_lang, target_lang, std::string());
   // While this is running call again TranslatePage to make sure noting bad
   // happens.
   translate_helper_->TranslatePage(original_lang, target_lang, std::string());
   base::MessageLoop::current()->RunUntilIdle();
 
   std::string received_original_lang;
   std::string received_target_lang;
-  TranslateErrors::Type error;
+  translate::TranslateErrors::Type error;
   ASSERT_TRUE(GetPageTranslatedMessage(&received_original_lang,
                                        &received_target_lang,
                                        &error));
   EXPECT_EQ(original_lang, received_original_lang);
   EXPECT_EQ(target_lang, received_target_lang);
-  EXPECT_EQ(TranslateErrors::NONE, error);
+  EXPECT_EQ(translate::TranslateErrors::NONE, error);
 }
 
 // Tests that starting a translation while a different one is pending works.
 TEST_F(TranslateHelperBrowserTest, MultipleDifferentTranslations) {
   EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*translate_helper_, StartTranslation())
@@ skipping 11 matching lines @@
   std::string target_lang("fr");
   translate_helper_->TranslatePage(original_lang, target_lang, std::string());
   // While this is running call again TranslatePage with a new target lang.
   std::string new_target_lang("de");
   translate_helper_->TranslatePage(
       original_lang, new_target_lang, std::string());
   base::MessageLoop::current()->RunUntilIdle();
 
   std::string received_original_lang;
   std::string received_target_lang;
-  TranslateErrors::Type error;
+  translate::TranslateErrors::Type error;
   ASSERT_TRUE(GetPageTranslatedMessage(&received_original_lang,
                                        &received_target_lang,
                                        &error));
   EXPECT_EQ(original_lang, received_original_lang);
   EXPECT_EQ(new_target_lang, received_target_lang);
-  EXPECT_EQ(TranslateErrors::NONE, error);
+  EXPECT_EQ(translate::TranslateErrors::NONE, error);
 }
 
 // Tests that we send the right translate language message for a page and that
 // we respect the "no translate" meta-tag.
 TEST_F(ChromeRenderViewTest, TranslatablePage) {
   // Suppress the normal delay that occurs when the page is loaded before which
   // the renderer sends the page contents to the browser.
   SendContentStateImmediately();
 
   LoadHTML("<html><body>A random page with random content.</body></html>");
@@ skipping 126 matching lines @@
 
   GoBack(back_state);
 
   message = render_thread_->sink().GetUniqueMessageMatching(
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
   EXPECT_EQ("zh", params.a.adopted_language);
   render_thread_->sink().ClearMessages();
 }