PrerenderingLoader initial integration with PrerenderManager/PrerenderHandle

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 "chrome/browser/prerender/prerender_manager.h"
+#include "chrome/browser/prerender/prerender_manager_factory.h"
+#include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace offline_pages {
 
-PrerenderingLoader::PrerenderingLoader(
-    content::BrowserContext* browser_context) {}
+PrerenderingLoader::PrerenderingLoader(content::BrowserContext* browser_context)
+    : state_(State::IDLE),
+      browser_context_(browser_context),
+      adapter_(new PrerenderAdapter()) {}
 
-PrerenderingLoader::~PrerenderingLoader() {}
+PrerenderingLoader::~PrerenderingLoader() {
+  CancelPrerender();
+}
 
-bool PrerenderingLoader::LoadPage(
-    const GURL& url,
-    const LoadPageCallback& callback) {
-  // TODO(dougarnett): implement.
-  return false;
+bool PrerenderingLoader::LoadPage(const GURL& url,
+                                  const LoadPageCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (state_ != State::IDLE) {

[fgorski, 2016/05/13 17:39:58]

if (!IsIdle())

[dougarnett, 2016/05/13 20:58:32]

Done.

+    DVLOG(1) << "WARNING: Existing request pending";
+    return false;
+  }
+  if (!CanPrerender())
+    return false;
+
+  // Create a WebContents instance to define and hold a SessionStorageNamespace
+  // for this load request.
+  DCHECK(!session_contents_.get());
+  session_contents_.reset(content::WebContents::Create(
+      content::WebContents::CreateParams(browser_context_)));
+
+  bool accepted = adapter_->StartPrerender(

[fgorski, 2016/05/13 17:39:58]

This code does not try to setobserver. Please make sure to try if the private
inheritance does not prevent it from working.

[dougarnett, 2016/05/13 20:58:32]

Not sure what you mean. It used to SetObserver here but now observer is passed
as StartPrerender arg and SetObserver done there (per gabadie comment).

Do you mean to just try this locally to prove the inheritance is working?

[fgorski, 2016/05/17 05:09:51]

Yes, getting the proof is what I was after.

[dougarnett, 2016/05/18 00:37:46]

Done (it did not work so dropped inheritance altogether).

+      browser_context_, url,
+      GetSessionStorageNamespace(session_contents_.get()),
+      GetSize(session_contents_.get()), this /* observer */);
+  if (!accepted)
+    return false;
+
+  DCHECK(adapter_->IsActive());
+  callback_ = callback;
+  state_ = State::LOADING;
+  return true;
 }
 
 void PrerenderingLoader::StopLoading() {
-  // TODO(dougarnett): implement.
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  CancelPrerender();
+}
+
+bool PrerenderingLoader::CanPrerender() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  // First check if prerendering is enabled.

[fgorski, 2016/05/13 17:39:58]

Is this comment relevant?

[dougarnett, 2016/05/13 20:58:32]

Done.

+  return adapter_->CanPrerender();
+}
+
+bool PrerenderingLoader::IsIdle() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return state_ == State::IDLE;
+}
+
+void PrerenderingLoader::SetAdapterForTesting(
+    PrerenderAdapter* prerender_adapter) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  adapter_.reset(prerender_adapter);
+}
+
+void PrerenderingLoader::OnPrerenderStart(prerender::PrerenderHandle* handle) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(adapter_->HasHandle(handle));

[fgorski, 2016/05/13 17:39:58]

Is there any state that is incorrect when this event is received.

[dougarnett, 2016/05/13 20:58:32]

Done.

+  if (state_ == State::PENDING) {
+    state_ = State::LOADING;
+  }
+}
+
+void PrerenderingLoader::OnPrerenderStopLoading(
+    prerender::PrerenderHandle* handle) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(adapter_->HasHandle(handle));
+  // TODO(dougarnett): Implement/integrate to delay policy here.
+  ReportLoadedIfStillLoading();
+}
+
+void PrerenderingLoader::OnPrerenderDomContentLoaded(
+    prerender::PrerenderHandle* handle) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(adapter_->HasHandle(handle));
+  // TODO(dougarnett): Implement/integrate to delay policy here.
+  ReportLoadedIfStillLoading();
+}
+
+void PrerenderingLoader::OnPrerenderStop(prerender::PrerenderHandle* handle) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(adapter_->HasHandle(handle));
+  ReportLoadFailedIfStillLoading();
+}
+
+content::SessionStorageNamespace*
+PrerenderingLoader::GetSessionStorageNamespace(content::WebContents* contents) {

[fgorski, 2016/05/13 17:39:58]

since this is a private method and you own the contents passed in, why not
simply refer to it here?

[dougarnett, 2016/05/13 20:58:32]

Done.

+  return contents->GetController().GetDefaultSessionStorageNamespace();
+}
+
+const gfx::Size PrerenderingLoader::GetSize(content::WebContents* contents) {

[fgorski, 2016/05/13 17:39:58]

ditto

[dougarnett, 2016/05/13 20:58:32]

Done.

+  return contents->GetContainerBounds().size();
+}
+
+void PrerenderingLoader::ReportLoadedIfStillLoading() {
+  // Make sure still loading in case some other load detection or canceling
+  // has already occurred.
+  if (state_ == State::LOADING) {
+    content::WebContents* contents = adapter_->GetWebContents();
+    if (contents) {
+      state_ = State::LOADED;
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(callback_, Offliner::RequestStatus::LOADED, contents));
+    } else {
+      ReportLoadFailedIfStillLoading();
+    }
+  }
+}
+
+void PrerenderingLoader::ReportLoadFailedIfStillLoading() {
+  // Check if load is still active to see if reporting is applicable.
+  if (state_ != State::LOADED && state_ != State::IDLE) {
+    if (adapter_->IsActive())
+      DVLOG(1) << "Load failed: " << adapter_->GetFinalStatus();
+    // TODO(dougarnett): Determine from final status if retry-able.
+    session_contents_.reset(nullptr);
+    state_ = State::IDLE;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(callback_, Offliner::RequestStatus::FAILED_DO_NOT_RETRY,
+                   nullptr));
+  }
+}
+
+void PrerenderingLoader::CancelPrerender() {
+  if (adapter_->IsActive()) {
+    adapter_->DestroyActive();
+  }
+  session_contents_.reset(nullptr);
+  if (state_ != State::LOADED && state_ != State::IDLE) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(callback_, Offliner::RequestStatus::CANCELED, nullptr));
+  }
+  state_ = State::IDLE;
 }
 
 }  // namespace offline_pages