[Offline pages]: Implement background loader to save on last retry, and record last retry success U…

chrome/browser/android/offline_pages/prerendering_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/prerendering_offliner.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_info.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
@@ skipping 20 matching lines @@
 
 PrerenderingOffliner::PrerenderingOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
     OfflinePageModel* offline_page_model)
     : browser_context_(browser_context),
       policy_(policy),
       offline_page_model_(offline_page_model),
       pending_request_(nullptr),
       is_low_end_device_(base::SysInfo::IsLowEndDevice()),
+      saved_on_last_retry_(false),
       app_listener_(nullptr),
       weak_ptr_factory_(this) {}
 
 PrerenderingOffliner::~PrerenderingOffliner() {}
 
 void PrerenderingOffliner::OnNetworkProgress(const SavePageRequest& request,
                                              int64_t bytes) {
   if (!pending_request_ || !progress_callback_)
     return;
 
@@ skipping 100 matching lines @@
 
   // Clear pending request and app listener here and then inform loader we
   // are done with WebContents.
   pending_request_.reset(nullptr);
   app_listener_.reset(nullptr);
   GetOrCreateLoader()->StopLoading();
 
   // Determine status and run the completion callback.
   Offliner::RequestStatus save_status;
   if (save_result == SavePageResult::SUCCESS) {
-    save_status = RequestStatus::SAVED;
+    if (saved_on_last_retry_)
+      save_status = RequestStatus::SAVED_ON_LAST_RETRY;
+    else
+      save_status = RequestStatus::SAVED;
   } else {
     // TODO(dougarnett): Consider reflecting some recommendation to retry the
     // request based on specific save error cases.
     save_status = RequestStatus::SAVE_FAILED;
   }
+  saved_on_last_retry_ = false;

[fgorski, 2017/04/17 17:48:59]

Would a single prerendering offliner be used for multiple snapshots? If so is
this covering all cases when this field has to be reset to false?

Otherwise, in case it does not take multiple snapshots, why bother resetting the
value?

[chili, 2017/04/17 19:37:52]

Good point. Added an additional clearing when we first LoadAndSave a page. The
PrerenderingOffliner is used across multiple snapshots.

   completion_callback_.Run(request, save_status);
 }
 
 bool PrerenderingOffliner::LoadAndSave(
     const SavePageRequest& request,
     const CompletionCallback& completion_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(!pending_request_.get());
 
   if (pending_request_) {
@@ skipping 84 matching lines @@
   callback.Run(request_id);
 }
 
 bool PrerenderingOffliner::HandleTimeout(const SavePageRequest& request) {
   if (pending_request_) {
     DCHECK(request.request_id() == pending_request_->request_id());
     if (GetOrCreateLoader()->IsLowbarMet() &&
         (request.started_attempt_count() + 1 >= policy_->GetMaxStartedTries() ||
          request.completed_attempt_count() + 1 >=
              policy_->GetMaxCompletedTries())) {
+      saved_on_last_retry_ = true;
       GetOrCreateLoader()->StartSnapshot();
       return true;
     }
   }
   return false;
 }
 
 void PrerenderingOffliner::SetLoaderForTesting(
     std::unique_ptr<PrerenderingLoader> loader) {
   DCHECK(!loader_);
@@ skipping 42 matching lines @@
 void PrerenderingOffliner::HandleApplicationStateChangeCancel(
     const SavePageRequest& request,
     int64_t offline_id) {
   // This shouldn't be immediate, but account for case where request was reset
   // while waiting for callback.
   if (pending_request_ && pending_request_->request_id() != offline_id)
     return;
   completion_callback_.Run(request, RequestStatus::FOREGROUND_CANCELED);
 }
 }  // namespace offline_pages