[translate] Add translate ranker model loader.

components/translate/core/browser/translate_ranker_impl_unittest.cc

Index: components/translate/core/browser/translate_ranker_impl_unittest.cc
diff --git a/components/translate/core/browser/translate_ranker_unittest.cc b/components/translate/core/browser/translate_ranker_impl_unittest.cc
similarity index 60%
rename from components/translate/core/browser/translate_ranker_unittest.cc
rename to components/translate/core/browser/translate_ranker_impl_unittest.cc
index 2c24bc921a90f8574ba6324b0329a240afdae71d..5ea72c93602580623aed014fd0de418e0d160e74 100644
--- a/components/translate/core/browser/translate_ranker_unittest.cc
+++ b/components/translate/core/browser/translate_ranker_impl_unittest.cc
@@ -2,31 +2,43 @@
 // 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_ranker.h"
+#include "components/translate/core/browser/translate_ranker_impl.h"
 
 #include <initializer_list>
 #include <memory>
 
 #include "base/feature_list.h"
+#include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/test/scoped_feature_list.h"
+#include "base/test/scoped_task_scheduler.h"
 #include "components/metrics/proto/translate_event.pb.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "components/translate/core/browser/proto/ranker_model.pb.h"
 #include "components/translate/core/browser/proto/translate_ranker_model.pb.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_prefs.h"
+#include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace translate {
 
-class TranslateRankerTest : public ::testing::Test {
+class TranslateRankerImplTest : public ::testing::Test {
  protected:
-  TranslateRankerTest() {}
+  TranslateRankerImplTest() {}
 
   void SetUp() override {
+    // Setup the translate download manager.
     locale_ = TranslateDownloadManager::GetInstance()->application_locale();
+    request_context_getter_ = new net::TestURLRequestContextGetter(
+        base::CreateSingleThreadTaskRunnerWithTraits(base::TaskTraits()));
     TranslateDownloadManager::GetInstance()->set_application_locale("zh-CN");
+    TranslateDownloadManager::GetInstance()->set_request_context(
+        request_context_getter_.get());
 
     // Setup a 50/50 accepted/denied count for "english" when initialize the
     // prefs and translate prefs.
@@ -42,7 +54,9 @@ class TranslateRankerTest : public ::testing::Test {
   }
 
   void TearDown() override {
+    base::RunLoop().RunUntilIdle();
     TranslateDownloadManager::GetInstance()->set_application_locale(locale_);
+    TranslateDownloadManager::GetInstance()->set_request_context(nullptr);
   }
 
   void InitFeatures(const std::initializer_list<base::Feature>& enabled,
@@ -50,10 +64,10 @@ class TranslateRankerTest : public ::testing::Test {
     scoped_feature_list_.InitWithFeatures(enabled, disabled);
   }
 
-  static std::unique_ptr<TranslateRanker> GetRankerForTest(float bias) {
-    chrome_intelligence::TranslateRankerModel model;
-    chrome_intelligence::TranslateRankerModel::LogisticRegressionModel*
-        details = model.mutable_logistic_regression_model();
+  std::unique_ptr<TranslateRankerImpl> GetRankerForTest(float bias) {
+    auto model = base::MakeUnique<chrome_intelligence::RankerModel>();
+    auto* details =
+        model->mutable_translate()->mutable_logistic_regression_model();
     details->set_bias(bias);
     details->set_accept_ratio_weight(0.02f);
     details->set_decline_ratio_weight(0.03f);
@@ -76,7 +90,10 @@ class TranslateRankerTest : public ::testing::Test {
     locale_weight["en-ca"] = 0.11f;
     locale_weight["zh-cn"] = 0.12f;  // Normalized to lowercase.
 
-    return TranslateRanker::CreateForTesting(model.SerializeAsString());
+    auto impl = base::MakeUnique<TranslateRankerImpl>(base::FilePath(), GURL());
+    impl->OnModelAvailable(std::move(model));
+    base::RunLoop().RunUntilIdle();
+    return impl;
   }
 
   static double Sigmoid(double x) { return 1.0 / (1.0 + exp(-x)); }
@@ -98,62 +115,88 @@ class TranslateRankerTest : public ::testing::Test {
 
   static const char* const kPreferredLanguagePrefs;
 
+  // Prefs.
   std::unique_ptr<sync_preferences::TestingPrefServiceSyncable> prefs_;
   std::unique_ptr<translate::TranslatePrefs> translate_prefs_;
 
  private:
+  // Sets up the task scheduling/task-runner environment for each test.
+  base::test::ScopedTaskScheduler scoped_task_scheduler_;
+
   // Manages the enabling/disabling of features within the scope of a test.
   base::test::ScopedFeatureList scoped_feature_list_;
 
   // Cache and reset the application locale for each test.
   std::string locale_;
 
-  DISALLOW_COPY_AND_ASSIGN(TranslateRankerTest);
+  // Used to initialize the translate download manager.
+  scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
+
+  DISALLOW_COPY_AND_ASSIGN(TranslateRankerImplTest);
 };
 
-const char* const TranslateRankerTest::kPreferredLanguagePrefs =
+const char* const TranslateRankerImplTest::kPreferredLanguagePrefs =
 #if defined(OS_CHROMEOS)
     "settings.language.preferred_languages";
 #else
     nullptr;
 #endif
 
-TEST_F(TranslateRankerTest, DisabledByDefault) {
+TEST_F(TranslateRankerImplTest, DisabledByDefault) {
   InitFeatures({}, {});
-  EXPECT_FALSE(TranslateRanker::IsEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsQueryEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsEnforcementEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsLoggingEnabled());
 }
 
-TEST_F(TranslateRankerTest, Disabled) {
-  InitFeatures({}, {kTranslateRankerQuery, kTranslateRankerEnforcement});
-  EXPECT_FALSE(TranslateRanker::IsEnabled());
+TEST_F(TranslateRankerImplTest, ExplicitlyDisabled) {
+  InitFeatures({}, {kTranslateRankerQuery, kTranslateRankerEnforcement,
+                    kTranslateRankerLogging});
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsQueryEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsEnforcementEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsLoggingEnabled());
 }
 
-TEST_F(TranslateRankerTest, EnableQuery) {
+TEST_F(TranslateRankerImplTest, EnableQuery) {
   InitFeatures({kTranslateRankerQuery}, {kTranslateRankerEnforcement});
-  EXPECT_TRUE(TranslateRanker::IsEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsQueryEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsEnforcementEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsLoggingEnabled());
 }
 
-TEST_F(TranslateRankerTest, EnableEnforcement) {
+TEST_F(TranslateRankerImplTest, EnableEnforcement) {
   InitFeatures({kTranslateRankerEnforcement}, {kTranslateRankerQuery});
-  EXPECT_TRUE(TranslateRanker::IsEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsQueryEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsEnforcementEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsLoggingEnabled());
 }
 
-TEST_F(TranslateRankerTest, EnableQueryAndEnforcement) {
+TEST_F(TranslateRankerImplTest, EnableQueryAndEnforcement) {
   InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement}, {});
-  EXPECT_TRUE(TranslateRanker::IsEnabled());
-  EXPECT_FALSE(TranslateRanker::IsLoggingEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsQueryEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsEnforcementEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsLoggingEnabled());
 }
 
-TEST_F(TranslateRankerTest, EnableLogging) {
+TEST_F(TranslateRankerImplTest, EnableLogging) {
   InitFeatures({kTranslateRankerLogging}, {});
-  EXPECT_FALSE(TranslateRanker::IsEnabled());
-  EXPECT_TRUE(TranslateRanker::IsLoggingEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsQueryEnabled());
+  EXPECT_FALSE(GetRankerForTest(0.5)->IsEnforcementEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsLoggingEnabled());
 }
 
+TEST_F(TranslateRankerImplTest, EnableAll) {
+  InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement,
+                kTranslateRankerLogging},
+               {});
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsQueryEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsEnforcementEnabled());
+  EXPECT_TRUE(GetRankerForTest(0.5)->IsLoggingEnabled());
+}
 
-TEST_F(TranslateRankerTest, CalculateScore) {
+TEST_F(TranslateRankerImplTest, CalculateScore) {
   InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement}, {});
-  std::unique_ptr<translate::TranslateRanker> ranker = GetRankerForTest(0.01f);
+  auto ranker = GetRankerForTest(0.01f);
   // Calculate the score using: a 50:50 accept/decline ratio; the one-hot
   // values for the src lang, dest lang, locale and counry; and, the bias.
   double expected = Sigmoid(0.5 * 0.02f +  // accept ratio * weight
@@ -164,13 +207,19 @@ TEST_F(TranslateRankerTest, CalculateScore) {
                             1.0 * 0.07f +  // one-hot country * weight
                             1.0 * 0.12f +  // one-hot locale * weight
                             0.01f);        // bias
-
-  EXPECT_NEAR(expected,
-              ranker->CalculateScore(0.5, 0.5, 0.0, "en", "fr", "zh-CN", "us"),
-              0.000001);
+  TranslateRankerFeatures features;
+  features.src_lang = "en";
+  features.dst_lang = "fr";
+  features.country = "us";
+  features.app_locale = "zh-CN";
+  features.accepted_ratio = 0.5;
+  features.denied_ratio = 0.5;
+  features.ignored_ratio = 0.0;
+
+  EXPECT_NEAR(expected, ranker->CalculateScore(features), 0.000001);
 }
 
-TEST_F(TranslateRankerTest, ShouldOfferTranslation) {
+TEST_F(TranslateRankerImplTest, ShouldOfferTranslation) {
   InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement}, {});
   // With a bias of -0.5 en->fr is not over the threshold.
   EXPECT_FALSE(GetRankerForTest(-0.5f)->ShouldOfferTranslation(
@@ -180,7 +229,7 @@ TEST_F(TranslateRankerTest, ShouldOfferTranslation) {
                                                               "en", "fr"));
 }
 
-TEST_F(TranslateRankerTest, RecordAndFlushEvents) {
+TEST_F(TranslateRankerImplTest, RecordAndFlushEvents) {
   InitFeatures({kTranslateRankerLogging}, {});
   std::unique_ptr<translate::TranslateRanker> ranker = GetRankerForTest(0.0f);
   std::vector<metrics::TranslateEventProto> flushed_events;
@@ -189,12 +238,9 @@ TEST_F(TranslateRankerTest, RecordAndFlushEvents) {
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
-  auto event_1 = CreateTranslateEvent("fr", "en", 1, 0, 3);
-  auto event_2 = CreateTranslateEvent("jp", "en", 2, 0, 3);
-  auto event_3 = CreateTranslateEvent("es", "de", 4, 5, 6);
-  ranker->RecordTranslateEvent(event_1);
-  ranker->RecordTranslateEvent(event_2);
-  ranker->RecordTranslateEvent(event_3);
+  ranker->AddTranslateEvent(CreateTranslateEvent("fr", "en", 1, 0, 3));
+  ranker->AddTranslateEvent(CreateTranslateEvent("jp", "en", 2, 0, 3));
+  ranker->AddTranslateEvent(CreateTranslateEvent("es", "de", 4, 5, 6));
 
   // Capture the data and verify that it is as expected.
   ranker->FlushTranslateEvents(&flushed_events);
@@ -208,7 +254,7 @@ TEST_F(TranslateRankerTest, RecordAndFlushEvents) {
   EXPECT_EQ(0U, flushed_events.size());
 }
 
-TEST_F(TranslateRankerTest, LoggingDisabled) {
+TEST_F(TranslateRankerImplTest, LoggingDisabled) {
   InitFeatures({}, {kTranslateRankerLogging});
   std::unique_ptr<translate::TranslateRanker> ranker = GetRankerForTest(0.0f);
   std::vector<metrics::TranslateEventProto> flushed_events;
@@ -216,12 +262,9 @@ TEST_F(TranslateRankerTest, LoggingDisabled) {
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
-  auto event_1 = CreateTranslateEvent("fr", "en", 1, 0, 3);
-  auto event_2 = CreateTranslateEvent("jp", "en", 2, 0, 3);
-  auto event_3 = CreateTranslateEvent("es", "de", 4, 5, 6);
-  ranker->RecordTranslateEvent(event_1);
-  ranker->RecordTranslateEvent(event_2);
-  ranker->RecordTranslateEvent(event_3);
+  ranker->AddTranslateEvent(CreateTranslateEvent("fr", "en", 1, 0, 3));
+  ranker->AddTranslateEvent(CreateTranslateEvent("jp", "en", 2, 0, 3));
+  ranker->AddTranslateEvent(CreateTranslateEvent("es", "de", 4, 5, 6));
 
   // Logging is disabled, so no events should be cached.
   ranker->FlushTranslateEvents(&flushed_events);