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 (!IsIdle()) {
+    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());

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

don't need the .get() with !

[pasko, 2016/05/17 15:34:20]

FWIW, I would prefer to refer to session_contents in all contexts uniformly with
.get(). It seems it is a preferable way in prerendering code. Not sure if it is
covered by any style guide though.

[fgorski, 2016/05/17 15:54:54]

That sounds great, as long as we are consistent everywhere.

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

Done.

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

Going without the .get() for now. 

PrerenderManager does not use .get() for DCHECK(contents_) but PrerenderContents
does DCHECK(prerender_contents_.get())

+  session_contents_.reset(content::WebContents::Create(
+      content::WebContents::CreateParams(browser_context_)));
+  if (!observer_.get())

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

ditto

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

Done.

+    observer_.reset(new PrerenderingLoader::ObserverDelegate(this));
+
+  bool accepted = adapter_->StartPrerender(browser_context_, url,
+                                           GetSessionStorageNamespace(),
+                                           GetSize(), observer_.get());
+  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);
+  return adapter_->CanPrerender();
+}
+
+bool PrerenderingLoader::IsIdle() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return state_ == State::IDLE;
+}
+
+bool PrerenderingLoader::IsLoaded() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return state_ == State::LOADED;
+}
+
+void PrerenderingLoader::SetAdapterForTesting(
+    PrerenderAdapter* prerender_adapter) {

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

std::unique_ptr<PrerenderAdapter>
Please tell the compiler you are taking ownership of the adapter.

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

Done.

+  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));
+  DCHECK(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() {
+  DCHECK(session_contents_.get());
+  return session_contents_->GetController().GetDefaultSessionStorageNamespace();
+}
+
+const gfx::Size PrerenderingLoader::GetSize() {
+  DCHECK(session_contents_.get());
+  return session_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 (!IsLoaded() && !IsIdle()) {
+    if (adapter_->IsActive()) {
+      DVLOG(1) << "Load failed: " << adapter_->GetFinalStatus();
+      adapter_->DestroyActive();
+    }
+    // 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 (!IsLoaded() && !IsIdle()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(callback_, Offliner::RequestStatus::CANCELED, nullptr));
+  }
+  state_ = State::IDLE;
+}
+
+// ObserverDelegate implementation:
+
+PrerenderingLoader::ObserverDelegate::ObserverDelegate(
+    PrerenderingLoader* loader)
+    : loader_(loader) {}

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

DCHECK(loader); ?

you are calling methods on it later, without checking.

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

Done.

+
+PrerenderingLoader::ObserverDelegate::~ObserverDelegate() {}
+
+void PrerenderingLoader::ObserverDelegate::OnPrerenderStart(
+    prerender::PrerenderHandle* handle) {
+  loader_->OnPrerenderStart(handle);
+}
+
+void PrerenderingLoader::ObserverDelegate::OnPrerenderStopLoading(
+    prerender::PrerenderHandle* handle) {
+  loader_->OnPrerenderDomContentLoaded(handle);
+}
+
+void PrerenderingLoader::ObserverDelegate::OnPrerenderDomContentLoaded(
+    prerender::PrerenderHandle* handle) {
+  loader_->OnPrerenderDomContentLoaded(handle);
+}
+
+void PrerenderingLoader::ObserverDelegate::OnPrerenderStop(
+    prerender::PrerenderHandle* handle) {
+  loader_->OnPrerenderStop(handle);
 }
 
 }  // namespace offline_pages