[Offline Pages] Add a timer to BackgroundLoaderOffliner to delay SavePage by 2 seconds.

chrome/browser/android/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/android/offline_pages/background_loader_offliner.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_info.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "chrome/browser/android/offline_pages/offliner_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/offline_pages/core/background/save_page_request.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/offline_page_model.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/web_contents.h"
 
 namespace offline_pages {
 
+namespace {
+long kOfflinePageDelayMs = 2000;
+}  // namespace
+
 BackgroundLoaderOffliner::BackgroundLoaderOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
     OfflinePageModel* offline_page_model)
     : browser_context_(browser_context),
       offline_page_model_(offline_page_model),
       is_low_end_device_(base::SysInfo::IsLowEndDevice()),
       save_state_(NONE),
       page_load_state_(SUCCESS),
+      page_delay_ms_(kOfflinePageDelayMs),
       weak_ptr_factory_(this) {
   DCHECK(offline_page_model_);
   DCHECK(browser_context_);
 }
 
 BackgroundLoaderOffliner::~BackgroundLoaderOffliner() {}
 
 bool BackgroundLoaderOffliner::LoadAndSave(const SavePageRequest& request,
                                            const CompletionCallback& callback) {
   DCHECK(callback);
@@ skipping 47 matching lines @@
   }
 
   if (!OfflinePageModel::CanSaveURL(request.url())) {
     DVLOG(1) << "Not able to save page for requested url: " << request.url();
     return false;
   }
 
   if (!loader_)
     ResetState();
 
+  // Invalidate ptrs for all delayed/saving tasks.
+  weak_ptr_factory_.InvalidateWeakPtrs();
+
   // Track copy of pending request.
   pending_request_.reset(new SavePageRequest(request));
   completion_callback_ = 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.
@@ skipping 15 matching lines @@
 
   ResetState();
 }
 
 void BackgroundLoaderOffliner::DidStopLoading() {
   if (!pending_request_.get()) {
     DVLOG(1) << "DidStopLoading called even though no pending request.";
     return;
   }
 
-  SavePageRequest request(*pending_request_.get());
-  // If there was an error navigating to page, return loading failed.
-  if (page_load_state_ != SUCCESS) {
-    Offliner::RequestStatus status =
-        (page_load_state_ == RETRIABLE)
-            ? Offliner::RequestStatus::LOADING_FAILED
-            : Offliner::RequestStatus::LOADING_FAILED_NO_RETRY;
-    completion_callback_.Run(request, status);
-    ResetState();
-    return;
-  }
+  // Invalidate ptrs for any ongoing save operation.
+  weak_ptr_factory_.InvalidateWeakPtrs();
 
-  save_state_ = SAVING;
-  content::WebContents* web_contents(
-      content::WebContentsObserver::web_contents());
-
-  std::unique_ptr<OfflinePageArchiver> archiver(
-      new OfflinePageMHTMLArchiver(web_contents));
-
-  OfflinePageModel::SavePageParams params;
-  params.url = web_contents->GetLastCommittedURL();
-  params.client_id = request.client_id();
-  params.proposed_offline_id = request.request_id();
-  params.is_background = true;
-
-  // Pass in the original URL if it's different from last committed
-  // when redirects occur.
-  if (params.url != request.url())
-    params.original_url = request.url();
-
-  offline_page_model_->SavePage(
-      params, std::move(archiver),
-      base::Bind(&BackgroundLoaderOffliner::OnPageSaved,
-                 weak_ptr_factory_.GetWeakPtr()));
+  // Post SavePage task with 2 second delay.
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&BackgroundLoaderOffliner::SavePage,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::TimeDelta::FromMilliseconds(page_delay_ms_));
 }
 
 void BackgroundLoaderOffliner::RenderProcessGone(
     base::TerminationStatus status) {
   if (pending_request_) {
     SavePageRequest request(*pending_request_.get());
     switch (status) {
       case base::TERMINATION_STATUS_OOM:
       case base::TERMINATION_STATUS_PROCESS_CRASHED:
       case base::TERMINATION_STATUS_STILL_RUNNING:
@@ skipping 47 matching lines @@
       case net::ERR_SSL_PROTOCOL_ERROR:
       case net::ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED:
       case net::ERR_SSL_SERVER_CERT_BAD_FORMAT:
       case net::ERR_UNKNOWN_URL_SCHEME:
         page_load_state_ = NONRETRIABLE;
         break;
       default:
         page_load_state_ = RETRIABLE;
     }
   }
+
+  // If the page is not the same, invalidate any pending save tasks.
+  //
+  // Downloads or 204/205 response codes do not commit (no new navigation)
+  // Same-Page (committed) navigations are:
+  // - reference fragment navigations
+  // - pushState/replaceState
+  // - same page history navigation
+  if (navigation_handle->HasCommitted() && !navigation_handle->IsSamePage())
+    weak_ptr_factory_.InvalidateWeakPtrs();
+}
+
+void BackgroundLoaderOffliner::SetPageDelayForTest(long delay_ms) {
+  page_delay_ms_ = delay_ms;
+}
+
+void BackgroundLoaderOffliner::SavePage() {
+  if (!pending_request_.get()) {
+    DVLOG(1) << "Pending request was cleared during delay.";
+    return;
+  }
+
+  SavePageRequest request(*pending_request_.get());
+  // If there was an error navigating to page, return loading failed.
+  if (page_load_state_ != SUCCESS) {
+    Offliner::RequestStatus status =
+        (page_load_state_ == RETRIABLE)
+            ? Offliner::RequestStatus::LOADING_FAILED
+            : Offliner::RequestStatus::LOADING_FAILED_NO_RETRY;
+    completion_callback_.Run(request, status);
+    ResetState();
+    return;
+  }
+
+  save_state_ = SAVING;
+  content::WebContents* web_contents(
+      content::WebContentsObserver::web_contents());
+
+  std::unique_ptr<OfflinePageArchiver> archiver(
+      new OfflinePageMHTMLArchiver(web_contents));
+
+  OfflinePageModel::SavePageParams params;
+  params.url = web_contents->GetLastCommittedURL();
+  params.client_id = request.client_id();
+  params.proposed_offline_id = request.request_id();
+  params.is_background = true;
+
+  // Pass in the original URL if it's different from last committed
+  // when redirects occur.
+  if (params.url != request.url())
+    params.original_url = request.url();
+
+  offline_page_model_->SavePage(
+      params, std::move(archiver),
+      base::Bind(&BackgroundLoaderOffliner::OnPageSaved,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BackgroundLoaderOffliner::OnPageSaved(SavePageResult save_result,
                                            int64_t offline_id) {
   if (!pending_request_)
     return;
 
   SavePageRequest request(*pending_request_.get());
   ResetState();
 
@@ skipping 32 matching lines @@
       application_state ==
           base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES) {
     DVLOG(1) << "App became active, canceling current offlining request";
     SavePageRequest* request = pending_request_.get();
     Cancel();
     completion_callback_.Run(*request, RequestStatus::FOREGROUND_CANCELED);
   }
 }
 
 }  // namespace offline_pages