[Offline Pages] Make prerenderer notify us of network progress.

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 70 matching lines @@
       snapshot_controller_(nullptr),
       browser_context_(browser_context) {
   adapter_.reset(new PrerenderAdapter(this));
 }
 
 PrerenderingLoader::~PrerenderingLoader() {
   CancelPrerender();
 }
 
 bool PrerenderingLoader::LoadPage(const GURL& url,
-                                  const LoadPageCallback& callback) {
+                                  const LoadPageCallback& load_done_callback,
+                                  const ProgressCallback& progress_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!IsIdle()) {
     DVLOG(1)
         << "WARNING: Existing request in progress or waiting for StopLoading()";
     return false;
   }
 
   // Create a WebContents instance to define and hold a SessionStorageNamespace
   // for this load request.
   DCHECK(!session_contents_.get());
   std::unique_ptr<content::WebContents> new_web_contents(
       content::WebContents::Create(
           content::WebContents::CreateParams(browser_context_)));
   content::SessionStorageNamespace* sessionStorageNamespace =
       new_web_contents->GetController().GetDefaultSessionStorageNamespace();
   gfx::Size renderWindowSize = new_web_contents->GetContainerBounds().size();
   bool accepted = adapter_->StartPrerender(
       browser_context_, url, sessionStorageNamespace, renderWindowSize);
   if (!accepted)
     return false;
 
   DCHECK(adapter_->IsActive());
   snapshot_controller_.reset(
       new SnapshotController(base::ThreadTaskRunnerHandle::Get(), this,
                              kOfflinePageDclDelayMs,
                              kOfflinePageOnloadDelayMs));
-  callback_ = callback;
+  load_done_callback_ = load_done_callback;
+  progress_callback_ = progress_callback;
   session_contents_.swap(new_web_contents);
   state_ = State::LOADING;
   return true;
 }
 
 void PrerenderingLoader::StopLoading() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   CancelPrerender();
 }
 
@@ skipping 34 matching lines @@
     // second delay from this event).
     snapshot_controller_->DocumentAvailableInMainFrame();
   }
 }
 
 void PrerenderingLoader::OnPrerenderStop() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   HandleLoadingStopped();
 }
 
+void PrerenderingLoader::OnPrerenderNetworkBytesChanged(int64_t bytes) {
+  if (state_ == State::LOADING)
+    progress_callback_.Run(bytes);
+}
+
 void PrerenderingLoader::StartSnapshot() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   HandleLoadEvent();
 }
 
 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;
 
   content::WebContents* web_contents = adapter_->GetWebContents();
   if (web_contents) {
     state_ = State::LOADED;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(callback_, Offliner::RequestStatus::LOADED, web_contents));
+        FROM_HERE, base::Bind(load_done_callback_,
+                              Offliner::RequestStatus::LOADED, web_contents));
   } else {
     // No WebContents means that the load failed (and it stopped).
     HandleLoadingStopped();
   }
 }
 
 void PrerenderingLoader::HandleLoadingStopped() {
   // Loading has stopped so unless the Loader has already transitioned to the
   // idle state, clean up the previous request state, transition to the idle
   // state, and post callback.
@@ skipping 33 matching lines @@
     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;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(callback_, request_status, nullptr));
+      FROM_HERE, base::Bind(load_done_callback_, request_status, nullptr));
 }
 
 void PrerenderingLoader::CancelPrerender() {
   if (adapter_->IsActive()) {
     adapter_->DestroyActive();
   }
   snapshot_controller_.reset(nullptr);
   session_contents_.reset(nullptr);
   state_ = State::IDLE;
 }
 
 }  // namespace offline_pages