Move ranker_model_loader to a new component.

components/machine_intelligence/ranker_model_loader.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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_task_runner_handle.h"
-#include "components/translate/core/browser/proto/ranker_model.pb.h"
-#include "components/translate/core/browser/ranker_model.h"
-#include "components/translate/core/browser/translate_url_fetcher.h"
+#include "components/machine_intelligence/proto/ranker_model.pb.h"
+#include "components/machine_intelligence/ranker_model.h"
+#include "components/machine_intelligence/ranker_url_fetcher.h"
 
-namespace translate {
+namespace machine_intelligence {
 namespace {
 
-using chrome_intelligence::RankerModel;
-using chrome_intelligence::RankerModelProto;
-
-constexpr int kUrlFetcherId = 2;
-
 // The minimum duration, in minutes, between download attempts.
 constexpr int kMinRetryDelayMins = 3;
 
 // Suffixes for the various histograms produced by the backend.
 const char kWriteTimerHistogram[] = ".Timer.WriteModel";
 const char kReadTimerHistogram[] = ".Timer.ReadModel";
 const char kDownloadTimerHistogram[] = ".Timer.DownloadModel";
 const char kParsetimerHistogram[] = ".Timer.ParseModel";
 const char kModelStatusHistogram[] = ".Model.Status";
 
@@ skipping 44 matching lines @@
            << model_path.value() << "'.";
   MyScopedHistogramTimer timer(uma_prefix + kWriteTimerHistogram);
   base::ImportantFileWriter::WriteFileAtomically(model_path, model_data);
 }
 
 }  // namespace
 
 RankerModelLoader::RankerModelLoader(
     ValidateModelCallback validate_model_cb,
     OnModelAvailableCallback on_model_available_cb,
+    net::URLRequestContextGetter* request_context_getter,
     base::FilePath model_path,
     GURL model_url,
     std::string uma_prefix)
     : background_task_runner_(base::CreateSequencedTaskRunnerWithTraits(
           {base::MayBlock(), base::TaskPriority::BACKGROUND,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       validate_model_cb_(std::move(validate_model_cb)),
       on_model_available_cb_(std::move(on_model_available_cb)),
+      request_context_getter_(request_context_getter),
       model_path_(std::move(model_path)),
       model_url_(std::move(model_url)),
       uma_prefix_(std::move(uma_prefix)),
-      url_fetcher_(base::MakeUnique<TranslateURLFetcher>(kUrlFetcherId)),
+      url_fetcher_(base::MakeUnique<RankerURLFetcher>()),
       weak_ptr_factory_(this) {}
 
 RankerModelLoader::~RankerModelLoader() {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void RankerModelLoader::NotifyOfRankerActivity() {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   switch (state_) {
     case LoaderState::NOT_STARTED:
       if (!model_path_.empty()) {
         StartLoadFromFile();
         break;
       }
       // There was no configured model path. Switch the state to IDLE and
       // fall through to consider the URL.
       state_ = LoaderState::IDLE;
     case LoaderState::IDLE:
       if (model_url_.is_valid()) {
         StartLoadFromURL();
         break;
       }
       // There was no configured model URL. Switch the state to FINISHED and
       // fall through.
       state_ = LoaderState::FINISHED;
     case LoaderState::FINISHED:
     case LoaderState::LOADING_FROM_FILE:
     case LoaderState::LOADING_FROM_URL:
       // Nothing to do.
       break;
   }
 }
 
 void RankerModelLoader::StartLoadFromFile() {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(state_, LoaderState::NOT_STARTED);
   DCHECK(!model_path_.empty());
   state_ = LoaderState::LOADING_FROM_FILE;
   load_start_time_ = base::TimeTicks::Now();
   base::PostTaskAndReplyWithResult(background_task_runner_.get(), FROM_HERE,
                                    base::Bind(&LoadFromFile, model_path_),
                                    base::Bind(&RankerModelLoader::OnFileLoaded,
                                               weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RankerModelLoader::OnFileLoaded(const std::string& data) {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(state_, LoaderState::LOADING_FROM_FILE);
 
   // Record the duration of the download.
   RecordTimerHistogram(uma_prefix_ + kReadTimerHistogram,
                        base::TimeTicks::Now() - load_start_time_);
 
   // Empty data means |model_path| wasn't successfully read. Otherwise,
   // parse and validate the model.
   std::unique_ptr<RankerModel> model;
   if (data.empty()) {
@@ skipping 26 matching lines @@
     on_model_available_cb_.Run(std::move(model));
   }
 
   // Notify the state machine. This will immediately kick off a download if
   // one is required, instead of waiting for the next organic detection of
   // ranker activity.
   NotifyOfRankerActivity();
 }
 
 void RankerModelLoader::StartLoadFromURL() {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(state_, LoaderState::IDLE);
   DCHECK(model_url_.is_valid());
 
   // Do nothing if the download attempts should be throttled.
   if (base::TimeTicks::Now() < next_earliest_download_time_) {
     DVLOG(2) << "Last download attempt was too recent.";
     ReportModelStatus(RankerModelStatus::DOWNLOAD_THROTTLED);
     return;
   }
 
   // Kick off the next download attempt and reset the time of the next earliest
   // allowable download attempt.
   DVLOG(2) << "Downloading model from: " << model_url_;
   state_ = LoaderState::LOADING_FROM_URL;
   load_start_time_ = base::TimeTicks::Now();
   next_earliest_download_time_ =
       load_start_time_ + base::TimeDelta::FromMinutes(kMinRetryDelayMins);
-  bool request_started = url_fetcher_->Request(
-      model_url_, base::Bind(&RankerModelLoader::OnURLFetched,
-                             weak_ptr_factory_.GetWeakPtr()));
+  bool request_started =
+      url_fetcher_->Request(model_url_,
+                            base::Bind(&RankerModelLoader::OnURLFetched,
+                                       weak_ptr_factory_.GetWeakPtr()),
+                            request_context_getter_.get());
 
   // |url_fetcher_| maintains a request retry counter. If all allowed attempts
   // have already been exhausted, then the loader is finished and has abandoned
   // loading the model.
   if (!request_started) {
     DVLOG(2) << "Model download abandoned.";
     ReportModelStatus(RankerModelStatus::MODEL_LOADING_ABANDONED);
     state_ = LoaderState::FINISHED;
   }
 }
 
-void RankerModelLoader::OnURLFetched(int /* id */,
-                                     bool success,
-                                     const std::string& data) {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+void RankerModelLoader::OnURLFetched(bool success, const std::string& data) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(state_, LoaderState::LOADING_FROM_URL);
 
   // Record the duration of the download.
   RecordTimerHistogram(uma_prefix_ + kDownloadTimerHistogram,
                        base::TimeTicks::Now() - load_start_time_);
 
   // On request failure, transition back to IDLE. The loader will retry, or
   // enforce the max download attempts, later.
   if (!success || data.empty()) {
     DVLOG(2) << "Download from '" << model_url_ << "'' failed.";
@@ skipping 23 matching lines @@
     background_task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&SaveToFile, model_url_, model_path_,
                                   model->SerializeAsString(), uma_prefix_));
   }
 
   // The loader is finished. Transfer the model to the client.
   state_ = LoaderState::FINISHED;
   on_model_available_cb_.Run(std::move(model));
 }
 
-std::unique_ptr<chrome_intelligence::RankerModel>
-RankerModelLoader::CreateAndValidateModel(const std::string& data) {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+std::unique_ptr<RankerModel> RankerModelLoader::CreateAndValidateModel(
+    const std::string& data) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   MyScopedHistogramTimer timer(uma_prefix_ + kParsetimerHistogram);
   auto model = RankerModel::FromString(data);
   if (ReportModelStatus(model ? validate_model_cb_.Run(*model)
                               : RankerModelStatus::PARSE_FAILED) !=
       RankerModelStatus::OK) {
     return nullptr;
   }
   return model;
 }
 
 RankerModelStatus RankerModelLoader::ReportModelStatus(
     RankerModelStatus model_status) {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
       uma_prefix_ + kModelStatusHistogram, 1,
       static_cast<int>(RankerModelStatus::MAX),
       static_cast<int>(RankerModelStatus::MAX) + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   if (histogram)
     histogram->Add(static_cast<int>(model_status));
   return model_status;
 }
 
-}  // namespace translate
+}  // namespace machine_intelligence