[Offline pages] Integrate snapshot controller fully into background loader.

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/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_user_data.h"
 
 namespace offline_pages {
 
 namespace {
 const long kOfflinePageDelayMs = 2000;
+const long kOfflineDomContentLoadedMs = 25000;
 
 class OfflinerData : public content::WebContentsUserData<OfflinerData> {
  public:
   static void AddToWebContents(content::WebContents* webcontents,
                                BackgroundLoaderOffliner* offliner) {
     DCHECK(offliner);
     webcontents->SetUserData(UserDataKey(), std::unique_ptr<OfflinerData>(
                                                 new OfflinerData(offliner)));
   }
 
@@ skipping 111 matching lines @@
   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_.reset(
+      new SnapshotController(base::ThreadTaskRunnerHandle::Get(), this,
+                             kOfflineDomContentLoadedMs, page_delay_ms_));
+
   return true;
 }
 
 void BackgroundLoaderOffliner::Cancel(const CancelCallback& callback) {
   // TODO(chili): We are not able to cancel a pending
-  // OfflinePageModel::SavePage() operation. We will notify caller that
+  // OfflinePageModel::SaveSnapshot() operation. We will notify caller that
   // cancel completed once the SavePage operation returns.
   if (!pending_request_) {
     callback.Run(0LL);
     return;
   }
 
   if (save_state_ != NONE) {
     save_state_ = DELETE_AFTER_SAVE;
     cancel_callback_ = callback;
     return;
   }
 
   int64_t request_id = pending_request_->request_id();
   ResetState();
   callback.Run(request_id);
 }
 
 bool BackgroundLoaderOffliner::HandleTimeout(const SavePageRequest& request) {
   // TODO(romax) Decide if we want to also take a snapshot on the last timeout
   // for the background loader offliner.
   return false;
 }
 
+void BackgroundLoaderOffliner::DocumentLoadedInFrame(
+    content::RenderFrameHost* render_host) {
+  if (!render_host->GetParent())

[Pete Williamson, 2017/03/27 21:45:45]

Let's add a comment here:
// If this was for the main frame, inform the snapshot controller.

[chili, 2017/03/27 23:43:43]

Done.

+    snapshot_controller_->DocumentAvailableInMainFrame();
+}
+
 void BackgroundLoaderOffliner::DidStopLoading() {
   if (!pending_request_.get()) {
     DVLOG(1) << "DidStopLoading called even though no pending request.";
     return;
   }
 
-  // Invalidate ptrs for any ongoing save operation.
-  weak_ptr_factory_.InvalidateWeakPtrs();
-
-  // 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_));
+  snapshot_controller_->DocumentOnLoadCompletedInMainFrame();
 }
 
 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 75 matching lines @@
   page_delay_ms_ = delay_ms;
 }
 
 void BackgroundLoaderOffliner::OnNetworkBytesChanged(int64_t bytes) {
   if (pending_request_ && save_state_ != SAVING) {
     network_bytes_ += bytes;
     progress_callback_.Run(*pending_request_, network_bytes_);
   }
 }
 
-void BackgroundLoaderOffliner::SavePage() {
+void BackgroundLoaderOffliner::StartSnapshot() {
   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;
     switch (page_load_state_) {
@@ skipping 60 matching lines @@
 
   Offliner::RequestStatus save_status;
   if (save_result == SavePageResult::SUCCESS)
     save_status = RequestStatus::SAVED;
   else
     save_status = RequestStatus::SAVE_FAILED;
 
   completion_callback_.Run(request, save_status);
 }
 
 void BackgroundLoaderOffliner::ResetState() {

[fgorski, 2017/03/27 22:51:54]

did you consider resetting the snapshot controller?

[chili, 2017/03/27 23:43:43]

Added now.

At first I didn't think it mattered as much, since we cleared the
pending_request_ and LoadAndSave resets the snapshot controller, and consistency
with prerenderer code. However, it's probably nicer to make this explicit

   pending_request_.reset();
   page_load_state_ = SUCCESS;
   network_bytes_ = 0LL;
   // TODO(chili): Remove after RequestCoordinator can handle multiple offliners.
   // We reset the loader and observer after completion so loaders
   // will not be re-used across different requests/tries. This is a temporary
   // solution while there exists assumptions about the number of offliners
   // there are.
   loader_.reset(
       new background_loader::BackgroundLoaderContents(browser_context_));
@@ skipping 22 matching lines @@
     int64_t offline_id) {
   // If for some reason the request was reset during while waiting for callback
   // ignore the completion callback.
   if (pending_request_ && pending_request_->request_id() != offline_id)
     return;
   completion_callback_.Run(request, RequestStatus::FOREGROUND_CANCELED);
 }
 }  // namespace offline_pages
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(offline_pages::OfflinerData);