PrerenderingLoader initial integration with PrerenderManager/PrerenderHandle

chrome/browser/android/offline_pages/prerendering_loader.cc

Index: chrome/browser/android/offline_pages/prerendering_loader.cc
diff --git a/chrome/browser/android/offline_pages/prerendering_loader.cc b/chrome/browser/android/offline_pages/prerendering_loader.cc
index 08576826a92db9984c60bbbfe2baf32711a173b8..d0385e53e846bb00599c7a98676304414dfa0458 100644
--- a/chrome/browser/android/offline_pages/prerendering_loader.cc
+++ b/chrome/browser/android/offline_pages/prerendering_loader.cc
@@ -4,26 +4,159 @@
 
 #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) {
+  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;
 
-bool PrerenderingLoader::LoadPage(
-    const GURL& url,
-    const LoadPageCallback& callback) {
-  // TODO(dougarnett): implement.
-  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