Allow TranslateRanker to override decisions taken by heuristics.

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_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, simulatng connection type changes for tests.
+// 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) {}
 
   // Simulates a change of the connection type to |type|. This will notify any
   // objects that are NetworkChangeNotifiers.
   void SimulateNetworkConnectionChange(
       net::NetworkChangeNotifier::ConnectionType type) {
     connection_type_to_return_ = type;
     net::NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
         connection_type_to_return_);
     base::RunLoop().RunUntilIdle();
   }
 
   void SimulateOffline() {
-    connection_type_to_return_ =net::NetworkChangeNotifier::CONNECTION_NONE;
+    connection_type_to_return_ = net::NetworkChangeNotifier::CONNECTION_NONE;
   }
 
   void SimulateOnline() {
     connection_type_to_return_ = net::NetworkChangeNotifier::CONNECTION_UNKNOWN;
   }
 
  private:
   ConnectionType GetCurrentConnectionType() const override {
     return connection_type_to_return_;
   }
@@ skipping 42 matching lines @@
 
   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),
@@ skipping 42 matching lines @@
 
   std::unique_ptr<base::Value> CreateProfileFromJSON(const char* json) {
     int error_code = 0;
     std::string error_msg;
     int error_line = 0;
     int error_column = 0;
 
     std::unique_ptr<base::Value> profile(base::JSONReader::ReadAndReturnError(
         json, 0, &error_code, &error_msg, &error_line, &error_column));
 
-    EXPECT_EQ(0, error_code) << error_msg << " at " << error_line << ":"
-                             << error_column << std::endl
-                             << json;
+    EXPECT_EQ(0, error_code)
+        << error_msg << " at " << error_line << ":" << error_column << std::endl
+        << json;
     return profile;
   }
 
   void TurnOnTranslateByULP() {
     scoped_refptr<base::FieldTrial> trial(
         CreateFieldTrial(kTrialName, 100, "Enabled", NULL));
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->RegisterFieldTrialOverride(
         translate::kTranslateLanguageByULP.name,
         base::FeatureList::OVERRIDE_ENABLE_FEATURE, trial.get());
     scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
   }
 
   scoped_refptr<base::FieldTrial> CreateFieldTrial(
       const std::string& trial_name,
       int total_probability,
       const std::string& default_group_name,
       int* default_group_number) {
     return base::FieldTrialList::FactoryGetFieldTrial(
         trial_name, total_probability, default_group_name,
         base::FieldTrialList::kNoExpirationYear, 1, 1,
         base::FieldTrial::SESSION_RANDOMIZED, default_group_number);
   }
 
+  void SetHasLanguageChanged(bool has_language_changed) {
+    translate_manager_->GetLanguageState().LanguageDetermined("de", true);
+    translate_manager_->GetLanguageState().DidNavigate(false, true, false);
+    translate_manager_->GetLanguageState().LanguageDetermined(
+        has_language_changed ? "en" : "de", true);
+    EXPECT_EQ(has_language_changed,
+              translate_manager_->GetLanguageState().HasLanguageChanged());
+  }
+
+  void SetLanguageTooOftenDenied(const std::string& language) {
+    if (base::FeatureList::IsEnabled(kTranslateUI2016Q2)) {
+      translate_prefs_.ResetDenialState();
+      for (int i = 0; i < 4; i++) {
+        translate_prefs_.IncrementTranslationDeniedCount(language);
+      }
+    } else {
+      translate_prefs_.UpdateLastDeniedTime(language);
+      translate_prefs_.UpdateLastDeniedTime(language);
+    }
+
+    EXPECT_TRUE(translate_prefs_.IsTooOftenDenied(language));
+    EXPECT_FALSE(translate_prefs_.IsTooOftenDenied("other_language"));
+  }
+
   // Functions to help TEST_F in subclass to access private functions in
-  // TranslteManager so we can unit test them.
+  // TranslateManager so we can unit test them.
   std::string CallGetTargetLanguageFromULP() {
     return TranslateManager::GetTargetLanguageFromULP(&translate_prefs_);
   }
   bool CallLanguageInULP(const std::string& language) {
     return translate_manager_->LanguageInULP(language);
   }
+  void InitTranslateEvent(const std::string& src_lang,
+                          const std::string& dst_lang) {
+    translate_manager_->InitTranslateEvent(src_lang, dst_lang,
+                                           translate_prefs_);
+  }
 
   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_;
   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"));
   manager_->set_application_locale("en");
   EXPECT_EQ("en", TranslateManager::GetTargetLanguage(&translate_prefs_));
 
   // Try a second supported language.
   ASSERT_TRUE(TranslateDownloadManager::IsSupportedLanguage("de"));
@@ skipping 74 matching lines @@
       1);
 }
 
 // Utility function to set the threshold params
 void ChangeThresholdInParams(
     const char* initiate_translation_confidence_threshold,
     const char* initiate_translation_probability_threshold,
     const char* target_language_confidence_threshold,
     const char* target_language_probability_threshold) {
   ASSERT_TRUE(variations::AssociateVariationParams(
-      kTrialName, "Enabled", {{"initiate_translation_ulp_confidence_threshold",
-                               initiate_translation_confidence_threshold},
-                              {"initiate_translation_ulp_probability_threshold",
-                               initiate_translation_probability_threshold},
-                              {"target_language_ulp_confidence_threshold",
-                               target_language_confidence_threshold},
-                              {"target_language_ulp_probability_threshold",
-                               target_language_probability_threshold}}));
+      kTrialName, "Enabled",
+      {{"initiate_translation_ulp_confidence_threshold",
+        initiate_translation_confidence_threshold},
+       {"initiate_translation_ulp_probability_threshold",
+        initiate_translation_probability_threshold},
+       {"target_language_ulp_confidence_threshold",
+        target_language_confidence_threshold},
+       {"target_language_ulp_probability_threshold",
+        target_language_probability_threshold}}));
 }
 
 // Normal ULP in Json
 const char ulp_1[] =
     "{\n"
     "  \"reading\": {\n"
     "    \"confidence\": 0.8,\n"
     "    \"preference\": [\n"
     "      {\n"
     "        \"language\": \"fr\",\n"
@@ skipping 99 matching lines @@
   // to 0.9.
   EXPECT_FALSE(CallLanguageInULP("fr"));
   EXPECT_FALSE(CallLanguageInULP("pt"));
   EXPECT_FALSE(CallLanguageInULP("zh-TW"));
 }
 
 TEST_F(TranslateManagerTest,
        TestLanguageInULPLowConfidenceThresholdFromConfig) {
   PrepareULPTest(ulp_1, true);
   ChangeThresholdInParams("0.79", "0.39", "", "");
-  // Both "fr" and "pt" should reutrn true because the confidence threshold is
+  // Both "fr" and "pt" should return true because the confidence threshold is
   // 0.79 and lower than 0.8 and the probability threshold is lower than both
   // the one with "fr" (0.6) and "pt-PT" (0.4).
   EXPECT_TRUE(CallLanguageInULP("fr"));
   EXPECT_TRUE(CallLanguageInULP("pt"));
   EXPECT_FALSE(CallLanguageInULP("zh-TW"));
 }
 
+TEST_F(TranslateManagerTest, TestRecordTranslateEvent) {
+  PrepareTranslateManager();
+  const std::string locale = "zh-TW";
+  const std::string page_lang = "zh-CN";
+  metrics::TranslateEventProto expected_tep;
+  expected_tep.set_target_language(locale);
+  expected_tep.set_source_language(page_lang);
+  EXPECT_CALL(
+      mock_translate_ranker_,
+      RecordTranslateEvent(metrics::TranslateEventProto::USER_ACCEPT, _,
+                           Pointee(EqualsTranslateEventProto(expected_tep))))
+      .Times(1);
+
+  InitTranslateEvent(page_lang, locale);
+  translate_manager_->RecordTranslateEvent(
+      metrics::TranslateEventProto::USER_ACCEPT);
+}
+
+TEST_F(TranslateManagerTest, TestShouldOverrideDecision) {
+  PrepareTranslateManager();
+  const int kEventType = 1;
+  EXPECT_CALL(
+      mock_translate_ranker_,
+      ShouldOverrideDecision(
+          kEventType, _,
+          Pointee(EqualsTranslateEventProto(metrics::TranslateEventProto()))))
+      .WillOnce(Return(false));
+  EXPECT_FALSE(translate_manager_->ShouldOverrideDecision(kEventType));
+
+  EXPECT_CALL(
+      mock_translate_ranker_,
+      ShouldOverrideDecision(
+          kEventType, _,
+          Pointee(EqualsTranslateEventProto(metrics::TranslateEventProto()))))
+      .WillOnce(Return(true));
+  EXPECT_TRUE(translate_manager_->ShouldOverrideDecision(kEventType));
+}
+
+TEST_F(TranslateManagerTest, ShouldSuppressBubbleUI_Default) {
+  PrepareTranslateManager();
+  SetHasLanguageChanged(true);
+  EXPECT_FALSE(translate_manager_->ShouldSuppressBubbleUI(false, "en"));
+  EXPECT_FALSE(translate_manager_->ShouldSuppressBubbleUI(true, "en"));
+}
+
+TEST_F(TranslateManagerTest, ShouldSuppressBubbleUI_HasLanguageChangedFalse) {
+  PrepareTranslateManager();
+  SetHasLanguageChanged(false);
+  EXPECT_CALL(
+      mock_translate_ranker_,
+      ShouldOverrideDecision(
+          metrics::TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE, _, _))
+      .WillOnce(Return(false));
+  EXPECT_TRUE(translate_manager_->ShouldSuppressBubbleUI(false, "en"));
+
+  EXPECT_CALL(mock_translate_ranker_, ShouldOverrideDecision(_, _, _))
+      .WillOnce(Return(false));
+
+  EXPECT_TRUE(translate_manager_->ShouldSuppressBubbleUI(true, "en"));
+}
+
+TEST_F(TranslateManagerTest, ShouldSuppressBubbleUI_NewUI) {
+  PrepareTranslateManager();
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(translate::kTranslateUI2016Q2);
+  SetHasLanguageChanged(false);
+  EXPECT_FALSE(translate_manager_->ShouldSuppressBubbleUI(false, "en"));
+}
+
+TEST_F(TranslateManagerTest, ShouldSuppressBubbleUI_IsTooOftenDenied) {
+  PrepareTranslateManager();
+  SetHasLanguageChanged(true);
+  SetLanguageTooOftenDenied("en");
+  EXPECT_CALL(
+      mock_translate_ranker_,
+      ShouldOverrideDecision(
+          metrics::TranslateEventProto::LANGUAGE_DISABLED_BY_AUTO_BLACKLIST, _,
+          _))
+      .WillOnce(Return(false));
+  EXPECT_TRUE(translate_manager_->ShouldSuppressBubbleUI(false, "en"));
+  EXPECT_FALSE(translate_manager_->ShouldSuppressBubbleUI(false, "de"));
+  EXPECT_FALSE(translate_manager_->ShouldSuppressBubbleUI(true, "en"));
+}
+
+TEST_F(TranslateManagerTest, ShouldSuppressBubbleUI_Override) {
+  PrepareTranslateManager();
+  EXPECT_CALL(
+      mock_translate_ranker_,
+      ShouldOverrideDecision(
+          metrics::TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE, _, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(
+      mock_translate_ranker_,
+      ShouldOverrideDecision(
+          metrics::TranslateEventProto::LANGUAGE_DISABLED_BY_AUTO_BLACKLIST, _,
+          _))
+      .WillOnce(Return(true));
+  SetHasLanguageChanged(false);
+  SetLanguageTooOftenDenied("en");
+  EXPECT_FALSE(translate_manager_->ShouldSuppressBubbleUI(false, "en"));
+}
+
 }  // namespace testing
 
 }  // namespace translate