Add translate client mock.

components/translate/core/browser/translate_manager_unittest.cc

 // Copyright 2015 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 "components/translate/core/browser/translate_manager.h"
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "build/build_config.h"
 #include "components/infobars/core/infobar.h"
 #include "components/metrics/proto/translate_event.pb.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "components/translate/core/browser/mock_translate_client.h"
 #include "components/translate/core/browser/mock_translate_driver.h"
 #include "components/translate/core/browser/mock_translate_ranker.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_pref_names.h"
 #include "components/translate/core/browser/translate_prefs.h"
 #include "components/variations/variations_associated_data.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::Pointee;
 
 namespace translate {
 
 namespace {
 
 const char kTrialName[] = "MyTrial";
 
-#if defined(OS_CHROMEOS)
-const char kLanguagePreferredLanguages[] =
-    "settings.language.preferred_languages";
-#else
-const char* kLanguagePreferredLanguages = nullptr;
-#endif
-const char kAcceptLanguages[] = "intl.accept_languages";
-
 // Overrides NetworkChangeNotifier, simulating connection type changes
 // for tests.
 // TODO(groby): Combine with similar code in ResourceRequestAllowedNotifierTest.
 class TestNetworkChangeNotifier : public net::NetworkChangeNotifier {
  public:
   TestNetworkChangeNotifier()
       : net::NetworkChangeNotifier(),
         connection_type_to_return_(
             net::NetworkChangeNotifier::CONNECTION_UNKNOWN) {}
 
@@ skipping 20 matching lines @@
     return connection_type_to_return_;
   }
 
   // The currently simulated network connection type. If this is set to
   // CONNECTION_NONE, then NetworkChangeNotifier::IsOffline will return true.
   net::NetworkChangeNotifier::ConnectionType connection_type_to_return_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkChangeNotifier);
 };
 
-// TODO(groby): Combine with MockTranslateClient in TranslateUiDelegateTest.
-class MockTranslateClient : public TranslateClient {
- public:
-  MockTranslateClient(TranslateDriver* driver, PrefService* prefs)
-      : driver_(driver), prefs_(prefs) {}
-
-  // TODO(groby): Does TranslateClient need a virtual dtor?
-  virtual ~MockTranslateClient() {}
-
-  TranslateDriver* GetTranslateDriver() { return driver_; }
-  PrefService* GetPrefs() { return prefs_; }
-
-  std::unique_ptr<TranslatePrefs> GetTranslatePrefs() {
-    return base::MakeUnique<TranslatePrefs>(prefs_, kAcceptLanguages,
-                                            kLanguagePreferredLanguages);
-  }
-  MOCK_METHOD0(GetTranslateAcceptLanguages, TranslateAcceptLanguages*());
-  MOCK_CONST_METHOD0(GetInfobarIconID, int());
-
-#if !defined(USE_AURA)
-  MOCK_CONST_METHOD1(CreateInfoBarMock,
-                     infobars::InfoBar*(TranslateInfoBarDelegate*));
-  std::unique_ptr<infobars::InfoBar> CreateInfoBar(
-      std::unique_ptr<TranslateInfoBarDelegate> delegate) const {
-    return base::WrapUnique(CreateInfoBarMock(std::move(delegate).get()));
-  }
-#endif
-
-  MOCK_METHOD5(ShowTranslateUI,
-               void(translate::TranslateStep,
-                    const std::string&,
-                    const std::string&,
-                    TranslateErrors::Type,
-                    bool));
-
-  MOCK_METHOD1(IsTranslatableURL, bool(const GURL&));
-  MOCK_METHOD1(ShowReportLanguageDetectionErrorUI,
-               void(const GURL& report_url));
-
- private:
-  TranslateDriver* driver_;
-  PrefService* prefs_;
-};
-
 // Compares TranslateEventProto on a restricted set of fields.
 MATCHER_P(EqualsTranslateEventProto, translate_event, "") {
   const metrics::TranslateEventProto& tep(translate_event);
   return (arg.source_language() == tep.source_language() &&
           arg.target_language() == tep.target_language() &&
           arg.event_type() == tep.event_type());
 }
 
 }  // namespace
 
 namespace testing {
 
 class TranslateManagerTest : public ::testing::Test {
  protected:
   TranslateManagerTest()
       : translate_prefs_(&prefs_,
-                         kAcceptLanguages,
-                         kLanguagePreferredLanguages),
+                         accept_languages_prefs,
+                         preferred_languages_prefs),
         manager_(TranslateDownloadManager::GetInstance()),
         mock_translate_client_(&driver_, &prefs_),
         field_trial_list_(new base::FieldTrialList(nullptr)) {}
 
   void SetUp() override {
     // Ensure we're not requesting a server-side translate language list.
     TranslateLanguageList::DisableUpdate();
-    prefs_.registry()->RegisterStringPref(kAcceptLanguages, std::string());
+    prefs_.registry()->RegisterStringPref(accept_languages_prefs,
+                                          std::string());
 #if defined(OS_CHROMEOS)
-    prefs_.registry()->RegisterStringPref(kLanguagePreferredLanguages,
+    prefs_.registry()->RegisterStringPref(preferred_languages_prefs,
                                           std::string());
 #endif
     TranslatePrefs::RegisterProfilePrefs(prefs_.registry());
     // TODO(groby): Figure out RegisterProfilePrefs() should register this.
     prefs_.registry()->RegisterBooleanPref(
         prefs::kEnableTranslate, true,
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
     manager_->ResetForTesting();
   }
 
   void TearDown() override {
     manager_->ResetForTesting();
     variations::testing::ClearAllVariationParams();
   }
 
   // Utility function to prepare translate_manager_ for testing.
   void PrepareTranslateManager() {
     TranslateManager::SetIgnoreMissingKeyForTesting(true);
     translate_manager_.reset(new translate::TranslateManager(
-        &mock_translate_client_, &mock_translate_ranker_, kAcceptLanguages));
+        &mock_translate_client_, &mock_translate_ranker_,
+        accept_languages_prefs));
   }
 
   // Prepare the test for ULP related tests.
   // Put the ulp json into profile.
   void PrepareULPTest(const char* ulp_json, bool turn_on_feature) {
     PrepareTranslateManager();
     std::unique_ptr<base::Value> profile(CreateProfileFromJSON(ulp_json));
     prefs_.SetUserPref(TranslatePrefs::kPrefLanguageProfile,
                        std::move(profile));
     if (turn_on_feature)
@@ skipping 76 matching lines @@
 
   sync_preferences::TestingPrefServiceSyncable prefs_;
 
   // TODO(groby): request TranslatePrefs from |mock_translate_client_| instead.
   TranslatePrefs translate_prefs_;
   TranslateDownloadManager* manager_;
 
   TestNetworkChangeNotifier network_notifier_;
   translate::testing::MockTranslateDriver driver_;
   translate::testing::MockTranslateRanker mock_translate_ranker_;
-  ::testing::NiceMock<MockTranslateClient> mock_translate_client_;
+  ::testing::NiceMock<translate::testing::MockTranslateClient>
+      mock_translate_client_;
   std::unique_ptr<TranslateManager> translate_manager_;
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 // Target language comes from application locale if the locale's language
 // is supported.
 TEST_F(TranslateManagerTest, GetTargetLanguageDefaultsToAppLocale) {
   // Ensure the locale is set to a supported language.
   ASSERT_TRUE(TranslateDownloadManager::IsSupportedLanguage("en"));
@@ skipping 46 matching lines @@
   // First supported language is the fallback language.
   ASSERT_TRUE(TranslateDownloadManager::IsSupportedLanguage("en"));
   accept_language_list.push_back("en");
   translate_prefs_.UpdateLanguageList(accept_language_list);
   EXPECT_EQ("en", TranslateManager::GetTargetLanguage(&translate_prefs_));
 }
 
 TEST_F(TranslateManagerTest, DontTranslateOffline) {
   TranslateManager::SetIgnoreMissingKeyForTesting(true);
   translate_manager_.reset(new translate::TranslateManager(
-      &mock_translate_client_, &mock_translate_ranker_, kAcceptLanguages));
+      &mock_translate_client_, &mock_translate_ranker_,
+      accept_languages_prefs));
 
   // The test measures that the "Translate was disabled" exit can only be
   // reached after the early-out tests including IsOffline() passed.
   const char kMetricName[] = "Translate.InitiationStatus.v2";
   base::HistogramTester histogram_tester;
 
   prefs_.SetBoolean(prefs::kEnableTranslate, false);
 
   translate_manager_->GetLanguageState().LanguageDetermined("de", true);
 
@@ skipping 253 matching lines @@
           _))
       .WillOnce(Return(true));
   SetHasLanguageChanged(false);
   SetLanguageTooOftenDenied("en");
   EXPECT_FALSE(translate_manager_->ShouldSuppressBubbleUI(false, "en"));
 }
 
 }  // namespace testing
 
 }  // namespace translate