Move ranker_model_loader to a new component.

components/machine_intelligence/ranker_model_loader_unittest.cc

 // Copyright 2017 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/ranker_model_loader.h"
+#include "components/machine_intelligence/ranker_model_loader.h"
 
 #include <deque>
 #include <initializer_list>
 #include <memory>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.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/task_scheduler/task_scheduler.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/scoped_task_scheduler.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.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/ranker_model.h"
-#include "components/translate/core/browser/translate_download_manager.h"
+#include "components/machine_intelligence/proto/ranker_model.pb.h"
+#include "components/machine_intelligence/proto/translate_ranker_model.pb.h"
+#include "components/machine_intelligence/ranker_model.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 using base::TaskScheduler;
-using chrome_intelligence::RankerModel;
-using translate::RankerModelLoader;
-using translate::RankerModelStatus;
-using translate::TranslateDownloadManager;
+using machine_intelligence::RankerModel;
+using machine_intelligence::RankerModelLoader;
+using machine_intelligence::RankerModelStatus;
 
 const char kInvalidModelData[] = "not a valid model";
 const int kInvalidModelSize = sizeof(kInvalidModelData) - 1;
 
 class RankerModelLoaderTest : public ::testing::Test {
  protected:
   RankerModelLoaderTest();
 
   void SetUp() override;
 
@@ skipping 35 matching lines @@
 
   // Sets up the task scheduling/task-runner environment for each test.
   base::test::ScopedTaskScheduler scoped_task_scheduler_;
 
   // Override the default URL fetcher to return custom responses for tests.
   net::FakeURLFetcherFactory url_fetcher_factory_;
 
   // Temporary directory for model files.
   base::ScopedTempDir scoped_temp_dir_;
 
-  // Cache and reset the application locale for each test.
-  std::string locale_;
-
-  // Used to initialize the translate download manager.
-  scoped_refptr<net::TestURLRequestContextGetter> request_context_;
+  // Used for URLFetcher.
+  scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
 
   // A queue of responses to return from Validate(). If empty, validate will
   // return 'OK'.
   std::deque<RankerModelStatus> validate_model_response_;
 
   // A cached to remember the model validation calls.
   std::vector<std::unique_ptr<RankerModel>> validated_models_;
 
   // A cache to remember the OnModelAvailable calls.
   std::vector<std::unique_ptr<RankerModel>> available_models_;
@@ skipping 14 matching lines @@
   RankerModel expired_model_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RankerModelLoaderTest);
 };
 
 RankerModelLoaderTest::RankerModelLoaderTest()
     : url_fetcher_factory_(nullptr) {}
 
 void RankerModelLoaderTest::SetUp() {
-  // Setup the translate download manager.
-  locale_ = TranslateDownloadManager::GetInstance()->application_locale();
-  request_context_ =
+  request_context_getter_ =
       new net::TestURLRequestContextGetter(base::ThreadTaskRunnerHandle::Get());
-  TranslateDownloadManager::GetInstance()->set_application_locale("fr-CA");
-  TranslateDownloadManager::GetInstance()->set_request_context(
-      request_context_.get());
 
   ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
   const auto& temp_dir_path = scoped_temp_dir_.GetPath();
 
   // Setup the model file paths.
   local_model_path_ = temp_dir_path.AppendASCII("local_model.bin");
   expired_model_path_ = temp_dir_path.AppendASCII("expired_model.bin");
   invalid_model_path_ = temp_dir_path.AppendASCII("invalid_model.bin");
 
   // Setup the model URLs.
   remote_model_url_ = GURL("https://some.url.net/good.model.bin");
   invalid_model_url_ = GURL("https://some.url.net/bad.model.bin");
   failed_model_url_ = GURL("https://some.url.net/fail");
 
   // Initialize the model data.
   ASSERT_NO_FATAL_FAILURE(InitRemoteModels());
   ASSERT_NO_FATAL_FAILURE(InitLocalModels());
 }
 
 void RankerModelLoaderTest::TearDown() {
   base::RunLoop().RunUntilIdle();
-  TranslateDownloadManager::GetInstance()->set_application_locale(locale_);
-  TranslateDownloadManager::GetInstance()->set_request_context(nullptr);
 }
 
 // static
 std::unique_ptr<RankerModel> RankerModelLoaderTest::Clone(
     const RankerModel& model) {
   auto copy = base::MakeUnique<RankerModel>();
   *copy->mutable_proto() = model.proto();
   return copy;
 }
 
@@ skipping 14 matching lines @@
 
   return IsEqual(*copy_m1, *copy_m2);
 }
 
 bool RankerModelLoaderTest::DoLoaderTest(const base::FilePath& model_path,
                                          const GURL& model_url) {
   auto loader = base::MakeUnique<RankerModelLoader>(
       base::Bind(&RankerModelLoaderTest::ValidateModel, base::Unretained(this)),
       base::Bind(&RankerModelLoaderTest::OnModelAvailable,
                  base::Unretained(this)),
-      model_path, model_url, "RankerModelLoaderTest");
+      request_context_getter_.get(), model_path, model_url,
+      "RankerModelLoaderTest");
   loader->NotifyOfRankerActivity();
   base::RunLoop().RunUntilIdle();
 
   return true;
 }
 
 void RankerModelLoaderTest::InitRemoteModels() {
   InitModel(remote_model_url_, base::Time(), base::TimeDelta(), &remote_model_);
   url_fetcher_factory_.SetFakeResponse(
       remote_model_url_, remote_model_.SerializeAsString(), net::HTTP_OK,
@@ skipping 152 matching lines @@
   validate_model_response_.push_back(RankerModelStatus::OK);
   validate_model_response_.push_back(RankerModelStatus::INCOMPATIBLE);
 
   ASSERT_TRUE(DoLoaderTest(expired_model_path_, remote_model_url_));
   ASSERT_EQ(2U, validated_models_.size());
   ASSERT_EQ(1U, available_models_.size());
   EXPECT_TRUE(IsEquivalent(*validated_models_[0], local_model_));
   EXPECT_TRUE(IsEquivalent(*validated_models_[1], remote_model_));
   EXPECT_TRUE(IsEquivalent(*available_models_[0], local_model_));
 }