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/web_contents.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace offline_pages {
 
-PrerenderingLoader::PrerenderingLoader(PrerenderManager* prerender_manager) {}
-
-PrerenderingLoader::~PrerenderingLoader() {}
-
-bool PrerenderingLoader::LoadPage(
+using PrerenderingAdapter = PrerenderingLoader::PrerenderingAdapter;
+
+PrerenderingLoader::PrerenderingLoader(content::BrowserContext* browser_context)
+    : browser_context_(browser_context), adapter_(new PrerenderingAdapter()) {}
+
+PrerenderingLoader::~PrerenderingLoader() {
+  CancelPrerender();
+}
+
+bool PrerenderingLoader::LoadPage(const GURL& url,
+                                  const LoadPageCallback& callback) {
+  if (state_ != State::kIdle) {
+    DVLOG(1) << "WARNING: Existing request pending";
+    return false;
+  }
+  if (!CanPrerender())
+    return false;
+
+  adapter_->AddPrerenderForOffline(browser_context_, url,
+                                   GetSessionStorageNamespace(), GetSize());
+  if (!adapter_->IsActive())
+    return false;
+
+  callback_ = callback;
+  adapter_->SetObserver(this);
+  state_ = State::kLoading;
+  return true;
+}
+
+void PrerenderingLoader::StopLoading() {
+  CancelPrerender();
+  state_ = State::kIdle;
+}
+
+bool PrerenderingLoader::CanPrerender() {
+  // First check if prerendering is enabled.
+  return adapter_->CanPrerender();
+}
+
+bool PrerenderingLoader::IsIdle() {
+  return state_ == State::kIdle;
+}
+
+content::SessionStorageNamespace*
+PrerenderingLoader::GetSessionStorageNamespace() {
+  // TODO(dougarnett): Create separate namespace from default (to better

[pasko, 2016/05/11 12:18:34]

my reading says that there is a 1:1 mapping between WebContentsImpl and its
NavigationControllerImpl.

The latter associates session_storage_namespace_map_[""] with a
SessionStorageNamespace on the first call to
GetDefaultSessionStorageNamespace().

So, if we avoid reusing the WebContents, the session storage namespace won't be
reused.

Also, I am not very comfortable having this TODO for more than a week, because
reusing the namespace with another (such as customtabs), would crash the
browser.

[dougarnett, 2016/05/11 21:10:14]

Nice

+  // isolate background loading artifacts from direct user browsing).
+  return content::WebContents::Create(

[pasko, 2016/05/11 12:18:34]

This would leak WebContents, right? I think we need to keep this tiny
WebContents around until the prerendered WebContents is destroyed.

[dougarnett, 2016/05/11 21:10:14]

Now holding onto this WebContents instance (in session_contents_) and releasing
in CancelPrerender()

+             content::WebContents::CreateParams(browser_context_))
+      ->GetController()
+      .GetDefaultSessionStorageNamespace();
+}
+
+const gfx::Size PrerenderingLoader::GetSize() {
+  return content::WebContents::Create(
+             content::WebContents::CreateParams(browser_context_))
+      ->GetContainerBounds()
+      .size();
+}
+
+void PrerenderingLoader::ReportLoaded() {
+  if (state_ == State::kLoading) {
+    content::WebContents* contents = adapter_->GetPrerenderContents();
+    if (contents) {
+      state_ = State::kLoaded;
+      // TODO(dougarnett): Post callback on the thread.

[pasko, 2016/05/11 12:18:34]

which thread?

[dougarnett, 2016/05/11 21:10:14]

Current thread. Went ahead and added the PostTask's

+      callback_.Run(true, contents);
+    } else {
+      ReportLoadFailed();
+    }
+  }
+}
+
+void PrerenderingLoader::ReportLoadFailed() {
+  if (state_ != State::kLoaded && state_ != State::kIdle) {
+    if (adapter_->IsActive())
+      DVLOG(1) << "Load failed: " << adapter_->GetFinalStatus();
+    state_ = State::kIdle;
+    // TODO(dougarnett): Post callback on the thread.
+    callback_.Run(false, nullptr);
+  }
+}
+
+void PrerenderingLoader::CancelPrerender() {
+  if (adapter_->IsPrerendering())
+    adapter_->OnCancel();
+  adapter_->DestroyActive();
+}
+
+void PrerenderingLoader::OnPrerenderStart(prerender::PrerenderHandle* handle) {
+  if (adapter_->IsActive(handle) && state_ == State::kPending) {
+    state_ = State::kLoading;
+  }
+}
+
+void PrerenderingLoader::OnPrerenderStopLoading(
+    prerender::PrerenderHandle* handle) {
+  if (adapter_->IsActive(handle)) {
+    // TODO(dougarnett): Implement/integrate to delay policy here.
+    ReportLoaded();
+  }
+}
+
+void PrerenderingLoader::OnPrerenderDomContentLoaded(
+    prerender::PrerenderHandle* handle) {
+  if (adapter_->IsActive(handle)) {
+    // TODO(dougarnett): Implement/integrate to delay policy here.
+    ReportLoaded();
+  }
+}
+
+void PrerenderingLoader::OnPrerenderStop(prerender::PrerenderHandle* handle) {
+  if (adapter_->IsActive(handle)) {
+    ReportLoadFailed();
+  }
+}
+
+void PrerenderingLoader::OnPrerenderCreatedMatchCompleteReplacement(
+    prerender::PrerenderHandle* handle) {
+  DVLOG(1) << "Offlining prerender should never do replacement";
+}
+
+void PrerenderingLoader::SetAdapterForTesting(
+    PrerenderingAdapter* prerendering_adapter) {
+  adapter_.reset(prerendering_adapter);
+}
+
+// Adapter implementation to prerender stack:
+
+bool PrerenderingAdapter::CanPrerender() const {
+  return prerender::PrerenderManager::ActuallyPrerendering();
+}
+
+bool PrerenderingAdapter::AddPrerenderForOffline(
+    content::BrowserContext* browser_context,
     const GURL& url,
     content::SessionStorageNamespace* session_storage_namespace,
-    const gfx::Size& size,
-    const LoadPageCallback& callback) {
-  // TODO(dougarnett): implement.
-  return false;
-}
-
-void PrerenderingLoader::StopLoading() {
-  // TODO(dougarnett): implement.
+    const gfx::Size& size) {
+  DCHECK(!IsActive());
+  Profile* profile = Profile::FromBrowserContext(browser_context);
+  prerender::PrerenderManager* manager =
+      prerender::PrerenderManagerFactory::GetForProfile(profile);
+  DCHECK(manager);
+  // Start prerendering the url and capture the handle for the prerendering.
+  active_handle_.reset(
+      manager->AddPrerenderForOffline(url, session_storage_namespace, size));
+  return active_handle_.get();
+}
+
+void PrerenderingAdapter::SetObserver(
+    prerender::PrerenderHandle::Observer* observer) {
+  active_handle_->SetObserver(observer);
+}
+
+bool PrerenderingAdapter::IsPrerendering() const {
+  return active_handle_->IsPrerendering();
+}
+
+void PrerenderingAdapter::OnCancel() {
+  active_handle_->OnCancel();
+}
+
+content::WebContents* PrerenderingAdapter::GetPrerenderContents() const {
+  if (active_handle_->contents()) {
+    // Note: the prerender stack maintains ownership of these contents
+    // and PrerenderingLoader::StopLoading() must be called to report
+    // the Loader is done with the contents.
+    return active_handle_->contents()->prerender_contents();
+  }
+  return nullptr;
+}
+
+prerender::FinalStatus PrerenderingAdapter::GetFinalStatus() const {
+  DCHECK(active_handle_->contents());
+  return active_handle_->contents()->final_status();
+}
+
+bool PrerenderingAdapter::IsActive() const {
+  return active_handle_.get();
+}
+
+bool PrerenderingAdapter::IsActive(prerender::PrerenderHandle* handle) const {
+  return active_handle_.get() == handle;
+}
+
+void PrerenderingAdapter::DestroyActive() {
+  active_handle_.reset(nullptr);
 }
 
 }  // namespace offline_pages