Integrate RankerModelLoader with TranslateRanker.

components/translate/core/browser/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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 15 matching lines @@
 namespace translate {
 namespace {
 
 using chrome_intelligence::RankerModel;
 using chrome_intelligence::RankerModelProto;
 
 constexpr int kUrlFetcherId = 2;
 
 // The maximum number of model download attempts to make. Download may fail
 // due to server error or network availability issues.
-constexpr int kMaxRetryOn5xx = 8;
+constexpr int kMaxDownloadAttempts = 8;
 
 // 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 94 matching lines @@
   // or the cached model is invalid/expired.
   const GURL model_url_;
 
   // This will prefix all UMA metrics generated by the model loader.
   const std::string uma_prefix_;
 
   // Used to download model data from |model_url_|.
   // TODO(rogerm): Use net::URLFetcher directly?
   std::unique_ptr<TranslateURLFetcher> url_fetcher_;
 
+  // The number of times the backend has attempted to download the model.
+  int download_attempts_;
+
   // The next time before which no new attempts to download the model should be
   // attempted.
   base::TimeTicks next_earliest_download_time_;
 
   // Tracks the last time of the last attempt to download a model. Used for UMA
   // reporting of download duration.
   base::TimeTicks download_start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
 RankerModelLoader::Backend::Backend(
     const ValidateModelCallback& validate_model_cb,
     const InternalOnModelAvailableCallback& internal_on_model_available_cb,
     const base::FilePath& model_path,
     const GURL& model_url,
     const std::string& uma_prefix)
     : origin_task_runner_(base::SequencedTaskRunnerHandle::Get()),
       validate_model_cb_(validate_model_cb),
       internal_on_model_available_cb_(internal_on_model_available_cb),
       model_path_(model_path),
       model_url_(model_url),
-      uma_prefix_(uma_prefix) {
+      uma_prefix_(uma_prefix),
+      url_fetcher_(base::MakeUnique<TranslateURLFetcher>(kUrlFetcherId)),
+      download_attempts_(0) {
   sequence_checker_.DetachFromSequence();
 }
 
 RankerModelLoader::Backend::~Backend() {}
 
 RankerModelStatus RankerModelLoader::Backend::ReportModelStatus(
     RankerModelStatus model_status) {
   base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
       uma_prefix_ + kModelStatusHistogram, 1,
       static_cast<int>(RankerModelStatus::MAX),
@@ skipping 67 matching lines @@
   }
 
   // Reaching this point means that a model download is required. If there is
   // no download URL configured, then there is nothing further to do.
   AsyncLoadFromURL();
 }
 
 void RankerModelLoader::Backend::AsyncLoadFromURL() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
-  if (!model_url_.is_valid())
+  if (!model_url_.is_valid()) {
+    // Notify the loader that model loading has been abandoned.
+    TransferModelToClient(nullptr, true);
     return;
+  }
 
   // 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.";
     return;
   }
 
-  // Otherwise, initialize the model fetcher to be non-null and trigger an
-  // initial download attempt.
-  if (!url_fetcher_) {
-    url_fetcher_ = base::MakeUnique<TranslateURLFetcher>(kUrlFetcherId);
-    url_fetcher_->set_max_retry_on_5xx(kMaxRetryOn5xx);
-  }
-
   // If a request is already in flight, do not issue a new one.
   if (url_fetcher_->state() == TranslateURLFetcher::REQUESTING) {
     DVLOG(2) << "Download is in progress.";
     return;
   }
 
+  // If all allowed attempts have been exhausted, notify the loader that the
+  // backend has abandoned the download.
+  if (++download_attempts_ > kMaxDownloadAttempts) {
+    DVLOG(2) << "Model download abandoned.";
+    ReportModelStatus(RankerModelStatus::DOWNLOAD_FAILED);
+    TransferModelToClient(nullptr, true);
+    return;
+  }
+
   DVLOG(2) << "Downloading model from: " << model_url_;
 
-  // Reset the time of the next earliest allowable download attempt.
+  // Kick off the next download attempt and reset the time of the next earliest
+  // allowable download attempt.
+  download_start_time_ = base::TimeTicks::Now();
   next_earliest_download_time_ =
-      base::TimeTicks::Now() + base::TimeDelta::FromMinutes(kMinRetryDelayMins);
-
-  // Kick off the next download attempt.
-  download_start_time_ = base::TimeTicks::Now();
-  bool result = url_fetcher_->Request(
+      download_start_time_ + base::TimeDelta::FromMinutes(kMinRetryDelayMins);
+  url_fetcher_->Request(
       model_url_, base::Bind(&RankerModelLoader::Backend::OnDownloadComplete,
                              base::Unretained(this)));
-
-  // The maximum number of download attempts has been surpassed. Don't make
-  // any further attempts.
-  if (!result) {
-    DVLOG(2) << "Model download abandoned.";
-    ReportModelStatus(RankerModelStatus::DOWNLOAD_FAILED);
-    url_fetcher_.reset();
-
-    // Notify the loader that model loading has been abandoned.
-    TransferModelToClient(nullptr, true);
-  }
 }
 
 void RankerModelLoader::Backend::OnDownloadComplete(int /* id */,
                                                     bool success,
                                                     const std::string& data) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // Record the duration of the download.
   base::TimeDelta duration = base::TimeTicks::Now() - download_start_time_;
   base::HistogramBase* counter = base::Histogram::FactoryTimeGet(
@@ skipping 99 matching lines @@
     std::unique_ptr<RankerModel> model,
     bool finished) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   if (finished)
     state_ = LoaderState::FINISHED;
   if (model)
     callback.Run(std::move(model));
 }
 
 }  // namespace translate