Split Android-specific dependency from BackgroundLoaderOffliner. Create a subfolder of c/b/offline_…

chrome/browser/offline_pages/background_loader_offliner.cc

 // Copyright 2016 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 "chrome/browser/offline_pages/background_loader_offliner.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_info.h"
@@ skipping 55 matching lines @@
   return adjusted_histogram_name;
 }
 
 void RecordErrorCauseUMA(const ClientId& client_id, net::Error error_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       AddHistogramSuffix(client_id,
                          "OfflinePages.Background.BackgroundLoadingFailedCode"),
       std::abs(error_code));
 }
 
-void HandleApplicationStateChangeCancel(
+void HandleLoadTerminationCancel(
     const Offliner::CompletionCallback& completion_callback,
     const SavePageRequest& canceled_request) {
   completion_callback.Run(canceled_request,
                           Offliner::RequestStatus::FOREGROUND_CANCELED);
 }
 
 }  // namespace
 
 BackgroundLoaderOffliner::BackgroundLoaderOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
-    OfflinePageModel* offline_page_model)
+    OfflinePageModel* offline_page_model,
+    std::unique_ptr<LoadTerminationListener> load_termination_listener)
     : browser_context_(browser_context),
       offline_page_model_(offline_page_model),
       policy_(policy),
-      is_low_end_device_(base::SysInfo::IsLowEndDevice()),
+      load_termination_listener_(std::move(load_termination_listener)),
       save_state_(NONE),
       page_load_state_(SUCCESS),
       network_bytes_(0LL),
       is_low_bar_met_(false),
       did_snapshot_on_last_retry_(false),
       weak_ptr_factory_(this) {
   DCHECK(offline_page_model_);
   DCHECK(browser_context_);
+  load_termination_listener_->set_offliner(this);
 }
 
 BackgroundLoaderOffliner::~BackgroundLoaderOffliner() {}
 
 // static
 BackgroundLoaderOffliner* BackgroundLoaderOffliner::FromWebContents(
     content::WebContents* contents) {
   OfflinerData* data = OfflinerData::FromWebContents(contents);
   if (data)
     return data->offliner();
@@ skipping 64 matching lines @@
   ResetLoader();
   AttachObservers();
 
   MarkLoadStartTime();
 
   // Track copy of pending request.
   pending_request_.reset(new SavePageRequest(request));
   completion_callback_ = completion_callback;
   progress_callback_ = progress_callback;
 
-  // Listen for app foreground/background change.
-  app_listener_.reset(new base::android::ApplicationStatusListener(
-      base::Bind(&BackgroundLoaderOffliner::OnApplicationStateChange,
-                 weak_ptr_factory_.GetWeakPtr())));
-
   // Load page attempt.
   loader_.get()->LoadPage(request.url());
 
   snapshot_controller_ = SnapshotController::CreateForBackgroundOfflining(
       base::ThreadTaskRunnerHandle::Get(), this);
 
   return true;
 }
 
 bool BackgroundLoaderOffliner::Cancel(const CancelCallback& callback) {
@@ skipping 12 matching lines @@
     return true;
   }
 
   // Post the cancel callback right after this call concludes.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, *pending_request_.get()));
   ResetState();
   return true;
 }
 
+void BackgroundLoaderOffliner::TerminateLoadIfInProgress() {
+  if (!pending_request_)
+    return;
+
+  Cancel(base::Bind(HandleLoadTerminationCancel, completion_callback_));
+}
+
 bool BackgroundLoaderOffliner::HandleTimeout(int64_t request_id) {
   if (pending_request_) {
     DCHECK(request_id == pending_request_->request_id());
     if (is_low_bar_met_ && (pending_request_->started_attempt_count() + 1 >=
                                 policy_->GetMaxStartedTries() ||
                             pending_request_->completed_attempt_count() + 1 >=
                                 policy_->GetMaxCompletedTries())) {
       // If we are already in the middle of a save operation, let it finish
       // but do not return SAVED_ON_LAST_RETRY
       if (save_state_ == NONE) {
@@ skipping 230 matching lines @@
   loader_.reset(
       new background_loader::BackgroundLoaderContents(browser_context_));
 }
 
 void BackgroundLoaderOffliner::AttachObservers() {
   content::WebContents* contents = loader_->web_contents();
   content::WebContentsObserver::Observe(contents);
   OfflinerData::AddToWebContents(contents, this);
 }
 
-void BackgroundLoaderOffliner::OnApplicationStateChange(
-    base::android::ApplicationState application_state) {
-  if (pending_request_ && is_low_end_device_ &&
-      application_state ==
-          base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES) {
-    DVLOG(1) << "App became active, canceling current offlining request";
-    // No need to check the return value or complete early, as false would
-    // indicate that there was no request, in which case the state change is
-    // ignored.
-    Cancel(
-        base::Bind(HandleApplicationStateChangeCancel, completion_callback_));
-  }
-}
-
 void BackgroundLoaderOffliner::AddLoadingSignal(const char* signal_name) {
   base::TimeTicks current_time = base::TimeTicks::Now();
   base::TimeDelta delay_so_far = current_time - load_start_time_;
   // We would prefer to use int64_t here, but JSON does not support that type.
   // Given the choice between int and double, we choose to implicitly convert to
   // a double since it maintains more precision (we can get a longer time in
   // milliseconds than we can with a 2 bit int, 53 bits vs 32).
   double delay = delay_so_far.InMilliseconds();
   signal_data_.SetDouble(signal_name, delay);
 }
 
 }  // namespace offline_pages
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(offline_pages::OfflinerData);