[Offline Pages] Allow BackgroundLoader to track network bytes using prerenderer hook-in.

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/downloads/download_ui_adapter.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;
+const long kOfflinePageDelayMs = 2000;
 }  // namespace
 
+BackgroundLoaderOffliner* BackgroundLoaderOffliner::offliner_ = nullptr;
+
 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),
+      network_bytes_(0LL),
       weak_ptr_factory_(this) {
   DCHECK(offline_page_model_);
   DCHECK(browser_context_);
+  offliner_ = this;
 }
 
 BackgroundLoaderOffliner::~BackgroundLoaderOffliner() {}
 
-// TODO(dimich): Invoke progress_callback as appropriate.
+// static
+BackgroundLoaderOffliner* BackgroundLoaderOffliner::FromWebContents(
+    content::WebContents* contents) {

[dewittj, 2017/03/09 22:33:17]

It might be better to get it this way:
auto context = contents->GetBrowserContext();
auto request_coordinator = RCFactory::GetForBrowserContext(context);
auto offliner = request_coordinator->GetOffliner()

Then you don't have dangling static pointers to worry about.

+  if (offliner_ && offliner_->web_contents() == contents)
+    return offliner_;
+  return nullptr;
+}
+
 bool BackgroundLoaderOffliner::LoadAndSave(
     const SavePageRequest& request,
     const CompletionCallback& completion_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(completion_callback);
   DCHECK(progress_callback);
 
   if (pending_request_) {
     DVLOG(1) << "Already have pending request";
     return false;
@@ skipping 49 matching lines @@
 
   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_ = 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());
 
   return true;
@@ skipping 121 matching lines @@
   if (navigation_handle->HasCommitted() &&
       !navigation_handle->IsSameDocument()) {
     weak_ptr_factory_.InvalidateWeakPtrs();
   }
 }
 
 void BackgroundLoaderOffliner::SetPageDelayForTest(long delay_ms) {
   page_delay_ms_ = delay_ms;
 }
 
+void BackgroundLoaderOffliner::OnNetworkBytesChanged(int64_t bytes) {
+  if (pending_request_ && save_state_ != SAVING) {
+    network_bytes_ += bytes;
+    SavePageRequest request(*pending_request_.get());
+    progress_callback_.Run(request, network_bytes_);
+  }
+}
+
 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;
@@ skipping 64 matching lines @@
     save_status = RequestStatus::SAVED;
   else
     save_status = RequestStatus::SAVE_FAILED;
 
   completion_callback_.Run(request, save_status);
 }
 
 void BackgroundLoaderOffliner::ResetState() {
   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_));
   content::WebContentsObserver::Observe(loader_.get()->web_contents());
 }
 
@@ skipping 15 matching lines @@
 void BackgroundLoaderOffliner::HandleApplicationStateChangeCancel(
     const SavePageRequest& request,
     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