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()) {}

[pasko, 2016/05/18 11:47:26]

If you are not planning to reset adapter_ in the PrerenderingLoader, making the
adapter a plain PrerenderAdapter member (instead of unique_ptr of it) would make
it easier to reason about the lifetime of the object, by only looking at the
header. Please do.

[fgorski, 2016/05/19 04:29:39]

There is setadapterfortesting(). I requested it to take the ownership.

 
-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());
+  session_contents_.reset(content::WebContents::Create(
+      content::WebContents::CreateParams(browser_context_)));
+  if (!observer_.get())

[pasko, 2016/05/18 11:47:26]

It would be simpler to have the observer class as a member, and initialized in
the PrerenderingLoader constructor. Less state. Lifetimes match.

.. but I proposed above to make it a part of the adapter, that would be
preferable.

[dougarnett, 2016/05/20 00:27:23]

Done.

+    observer_.reset(
+        new PrerenderingLoader::PrerenderHandleObserver(this, adapter_.get()));
+
+  bool accepted = adapter_->StartPrerender(browser_context_, url,
+                                           GetSessionStorageNamespace(),
+                                           GetSize(), observer_.get());
+  if (!accepted)
+    return false;
+
+  DCHECK(adapter_->IsActive());
+  callback_ = callback;
+  state_ = State::PENDING;
+  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(
+    std::unique_ptr<PrerenderAdapter> prerender_adapter) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  adapter_ = std::move(prerender_adapter);
+}
+
+void PrerenderingLoader::OnPrerenderStart() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(state_ == State::PENDING);
+  state_ = State::LOADING;
+}
+
+void PrerenderingLoader::OnPrerenderStopLoading() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  // TODO(dougarnett): Implement/integrate to delay policy here.
+  ReportLoadedIfStillLoading();
+}
+
+void PrerenderingLoader::OnPrerenderDomContentLoaded() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  // TODO(dougarnett): Implement/integrate to delay policy here.
+  ReportLoadedIfStillLoading();
+}
+
+void PrerenderingLoader::OnPrerenderStop() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  ReportLoadFailedIfStillLoading();
+}
+
+content::SessionStorageNamespace*
+PrerenderingLoader::GetSessionStorageNamespace() {
+  DCHECK(session_contents_);
+  return session_contents_->GetController().GetDefaultSessionStorageNamespace();
+}
+
+const gfx::Size PrerenderingLoader::GetSize() {
+  DCHECK(session_contents_);
+  return session_contents_->GetContainerBounds().size();
+}
+
+void PrerenderingLoader::ReportLoadedIfStillLoading() {
+  // Check if load is still active to see if reporting is applicable (i.e.,
+  // no other load detection or canceling has already occurred).
+  if (!IsLoaded() && !IsIdle()) {
+    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 and report
+    // different failure statuses if retry-able or not.
+    session_contents_.reset(nullptr);
+    state_ = State::IDLE;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(callback_, Offliner::RequestStatus::FAILED, 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;
+}
+
+// PrerenderHandleObserver implementation:
+
+PrerenderingLoader::PrerenderHandleObserver::PrerenderHandleObserver(
+    PrerenderingLoader* loader,
+    PrerenderAdapter* adapter)
+    : loader_(loader), adapter_(adapter) {
+  DCHECK(loader);
+  DCHECK(adapter);
+}
+
+PrerenderingLoader::PrerenderHandleObserver::~PrerenderHandleObserver() {}
+
+void PrerenderingLoader::PrerenderHandleObserver::OnPrerenderStart(
+    prerender::PrerenderHandle* handle) {
+  DCHECK(adapter_->HasHandle(handle));
+  loader_->OnPrerenderStart();
+}
+
+void PrerenderingLoader::PrerenderHandleObserver::OnPrerenderStopLoading(
+    prerender::PrerenderHandle* handle) {
+  DCHECK(adapter_->HasHandle(handle));
+  loader_->OnPrerenderDomContentLoaded();
+}
+
+void PrerenderingLoader::PrerenderHandleObserver::OnPrerenderDomContentLoaded(
+    prerender::PrerenderHandle* handle) {
+  DCHECK(adapter_->HasHandle(handle));
+  loader_->OnPrerenderDomContentLoaded();
+}
+
+void PrerenderingLoader::PrerenderHandleObserver::OnPrerenderStop(
+    prerender::PrerenderHandle* handle) {
+  DCHECK(adapter_->HasHandle(handle));
+  loader_->OnPrerenderStop();
 }
 
 }  // namespace offline_pages