[Offline Pages] Snapshotting on timeout of last retry.

chrome/browser/android/offline_pages/prerendering_loader.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_loader.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 61 matching lines @@
     case prerender::FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED:
     case prerender::FINAL_STATUS_WINDOW_PRINT:
     default:
       return Offliner::RequestStatus::LOADING_FAILED;
   }
 }
 
 PrerenderingLoader::PrerenderingLoader(content::BrowserContext* browser_context)
     : state_(State::IDLE),
       snapshot_controller_(nullptr),
-      browser_context_(browser_context) {
+      browser_context_(browser_context),
+      is_lowbar_met_(false) {
   adapter_.reset(new PrerenderAdapter(this));
 }
 
 PrerenderingLoader::~PrerenderingLoader() {
   CancelPrerender();
 }
 
 bool PrerenderingLoader::LoadPage(const GURL& url,
                                   const LoadPageCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 57 matching lines @@
   // when to consider it really LOADED.
   snapshot_controller_->DocumentOnLoadCompletedInMainFrame();
 }
 
 void PrerenderingLoader::OnPrerenderDomContentLoaded() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!IsIdle());
   if (!adapter_->GetWebContents()) {
     // Without a WebContents object at this point, we are done.
     HandleLoadingStopped();
-  } else if (kConsiderDclForSnapshot) {
-    // Inform SnapshotController of DomContentLoaded event so it can
-    // determine when to consider it really LOADED (e.g., some multiple
-    // second delay from this event).
-    snapshot_controller_->DocumentAvailableInMainFrame();
+  } else {
+    is_lowbar_met_ = true;
+    if (kConsiderDclForSnapshot) {
+      // Inform SnapshotController of DomContentLoaded event so it can
+      // determine when to consider it really LOADED (e.g., some multiple
+      // second delay from this event).
+      snapshot_controller_->DocumentAvailableInMainFrame();
+    }
   }
 }
 
 void PrerenderingLoader::OnPrerenderStop() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   HandleLoadingStopped();
 }
 
 void PrerenderingLoader::StartSnapshot() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   HandleLoadEvent();
 }
 
+bool PrerenderingLoader::IsLowbarMet() {
+  return is_lowbar_met_;
+}
+
 void PrerenderingLoader::HandleLoadEvent() {
   // If still loading, check if the load succeeded or not, then update
   // the internal state (LOADED for success or IDLE for failure) and post
   // callback.
   // Note: it is possible to receive a load event (e.g., if timeout-based)
   // after the request has completed via another path (e.g., canceled) so
   // the Loader may be idle at this point.
 
   if (IsIdle() || IsLoaded())
     return;
@@ skipping 49 matching lines @@
     // Now clean up the active prerendering operation detail.
     adapter_->DestroyActive();
   } else {
     // No access to FinalStatus so classify as retryable failure.
     request_status = Offliner::RequestStatus::LOADING_FAILED;
   }
 
   snapshot_controller_.reset(nullptr);
   session_contents_.reset(nullptr);
   state_ = State::IDLE;
+  is_lowbar_met_ = false;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback_, request_status, nullptr));
 }
 
 void PrerenderingLoader::CancelPrerender() {
   if (adapter_->IsActive()) {
     adapter_->DestroyActive();
   }
   snapshot_controller_.reset(nullptr);
   session_contents_.reset(nullptr);
   state_ = State::IDLE;
+  is_lowbar_met_ = false;
 }
 
 }  // namespace offline_pages