Adds unit tests for offline_pages::PrerenderAdapter calling PrerenderManager.

chrome/browser/android/offline_pages/prerender_adapter_unittest.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/prerender_adapter.h"
+
+#include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace offline_pages {
+
+class UnitTestPrerenderManager;
+
+namespace {
+
+class StubPrerenderContents : public prerender::PrerenderContents {
+ public:
+  StubPrerenderContents(UnitTestPrerenderManager* test_prerender_manager,
+                        const GURL& url,
+                        prerender::Origin origin);
+
+  ~StubPrerenderContents() override;
+
+  void StartPrerendering(
+      const gfx::Size& size,
+      content::SessionStorageNamespace* session_storage_namespace) override;
+};
+
+}  // namespace
+
+// Subclass of PrerenderManager for unit testing. This needs to be a friend
+// of PrerenderManager. Follows naming style used by prerender unittests (but
+// is in offline_pages namespace).
+class UnitTestPrerenderManager : public prerender::PrerenderManager {

[Pete Williamson, 2016/06/07 17:30:51]

Instead of inheriting from the PrerenderManager, should we be inheriting from an
interface that PrerenderManager implements?  We want to test the adapter, not
the prerenderManager as I understand it.  This may mean splitting
PrerenderManager into interface and implementation classes.

[dougarnett, 2016/06/11 00:21:55]

Change to injecting PrerenderContentsFactory. 
[Btw, if we did create interfaces for PrerenderManager and PrerenderHandle had
interfaces, we could drop the PrerenderAdapter]

+ public:
+  explicit UnitTestPrerenderManager(Profile* profile)
+      : PrerenderManager(profile), create_prerender_contents_called_(false) {}
+
+  ~UnitTestPrerenderManager() override {}
+
+  bool create_prerender_contents_called() const {
+    return create_prerender_contents_called_;
+  }
+
+ private:
+  prerender::PrerenderContents* CreatePrerenderContents(

[pasko, 2016/06/07 11:33:00]

or, alternatively, make this method protected.  Not sure, maybe you need more
methods.

[dougarnett, 2016/06/07 16:45:39]

Yes, making this protected is sufficient and seems preferable to me.

+      const GURL& url,
+      const content::Referrer& referrer,
+      prerender::Origin origin) override {
+    create_prerender_contents_called_ = true;
+    StubPrerenderContents* prerender_contents =
+        new StubPrerenderContents(this, url, prerender::ORIGIN_OFFLINE);
+    return prerender_contents;
+  }
+
+  bool create_prerender_contents_called_;
+};
+
+StubPrerenderContents::StubPrerenderContents(
+    UnitTestPrerenderManager* test_prerender_manager,
+    const GURL& url,
+    prerender::Origin origin)
+    : prerender::PrerenderContents(test_prerender_manager,
+                                   NULL,
+                                   url,
+                                   content::Referrer(),
+                                   origin) {}
+
+StubPrerenderContents::~StubPrerenderContents() {}
+
+void StubPrerenderContents::StartPrerendering(
+    const gfx::Size& size,
+    content::SessionStorageNamespace* session_storage_namespace) {
+  prerendering_has_started_ = true;
+}
+
+// Test class.
+class PrerenderAdapterTest : public testing::Test,
+                             public PrerenderAdapter::Observer {
+ public:
+  PrerenderAdapterTest();
+  ~PrerenderAdapterTest() override { unittest_prerender_manager_->Shutdown(); }
+
+  // PrerenderAdapter::Observer implementation:
+  void OnPrerenderStart() override;
+  void OnPrerenderStopLoading() override;
+  void OnPrerenderDomContentLoaded() override;
+  void OnPrerenderStop() override;
+
+  void SetUp() override;
+
+  // Returns the PrerenderLoader to test.
+  PrerenderAdapter* adapter() const { return adapter_.get(); }
+  UnitTestPrerenderManager* unittest_prerender_manager() {
+    return unittest_prerender_manager_.get();
+  }
+  Profile* profile() { return &profile_; }
+
+ private:
+  content::TestBrowserThreadBundle thread_bundle_;
+  TestingProfile profile_;
+  std::unique_ptr<PrerenderAdapter> adapter_;
+  std::unique_ptr<UnitTestPrerenderManager> unittest_prerender_manager_;
+  bool callback_called_;
+  //  Offliner::RequestStatus callback_load_status_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrerenderAdapterTest);
+};
+
+PrerenderAdapterTest::PrerenderAdapterTest()
+    : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
+
+void PrerenderAdapterTest::OnPrerenderStart() {}
+void PrerenderAdapterTest::OnPrerenderStopLoading() {}
+void PrerenderAdapterTest::OnPrerenderDomContentLoaded() {}
+void PrerenderAdapterTest::OnPrerenderStop() {}
+
+void PrerenderAdapterTest::SetUp() {
+  adapter_.reset(new PrerenderAdapter(this));
+  unittest_prerender_manager_.reset(new UnitTestPrerenderManager(profile()));
+  adapter()->SetPrerenderManagerForTest(unittest_prerender_manager());
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+}
+
+TEST_F(PrerenderAdapterTest, CanPrerender) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  EXPECT_TRUE(adapter()->CanPrerender());

[gabadie, 2016/06/07 12:02:08]

CanPrerender() { return true; } would pass the tests as well. I think a better
would be to add making sure CanPrerender() return false if
prerender::PrerenderManager::ActuallyPrerendering() return false.

[dougarnett, 2016/06/07 16:45:39]

True - but really just wanted to exercise the direct call to
ActuallyPrerendering() call here at least once to be sure it is allowed. I can
add another test if you think it is important and this CL moves forward.

[gabadie, 2016/06/07 18:41:12]

I think it would improve this CL. I think this same test should also tests what
append in StartPrerender() if CanPrerender() == false

[dougarnett, 2016/06/11 00:21:55]

Added CanPrerender == false test.

+}
+
+TEST_F(PrerenderAdapterTest, StartPrerenderFailsForUnsupportedScheme) {
+  content::WebContents* session_contents = content::WebContents::Create(
+      content::WebContents::CreateParams(profile()));
+  content::SessionStorageNamespace* sessionStorageNamespace =
+      session_contents->GetController().GetDefaultSessionStorageNamespace();
+  gfx::Size renderWindowSize = session_contents->GetContainerBounds().size();
+  GURL url("file://file.test");
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  EXPECT_FALSE(adapter()->StartPrerender(
+      profile(), url, sessionStorageNamespace, renderWindowSize));
+  EXPECT_TRUE(unittest_prerender_manager()->create_prerender_contents_called());
+  EXPECT_FALSE(adapter()->IsActive());
+}
+
+TEST_F(PrerenderAdapterTest, StartPrerenderSucceeds) {
+  content::WebContents* session_contents = content::WebContents::Create(
+      content::WebContents::CreateParams(profile()));
+  content::SessionStorageNamespace* sessionStorageNamespace =
+      session_contents->GetController().GetDefaultSessionStorageNamespace();
+  gfx::Size renderWindowSize = session_contents->GetContainerBounds().size();
+  GURL url("https://url.test");
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  EXPECT_TRUE(adapter()->StartPrerender(profile(), url, sessionStorageNamespace,
+                                        renderWindowSize));
+  EXPECT_TRUE(unittest_prerender_manager()->create_prerender_contents_called());
+  EXPECT_TRUE(adapter()->IsActive());
+
+  // Exercise access methods even though no interesting values set beneath.
+  EXPECT_EQ(nullptr, adapter()->GetWebContents());
+  EXPECT_EQ(prerender::FinalStatus::FINAL_STATUS_MAX,
+            adapter()->GetFinalStatus());
+
+  adapter()->DestroyActive();
+  EXPECT_FALSE(adapter()->IsActive());
+}
+
+// TODO(dougarnett): Test observer calls.
+
+}  // namespace offline_pages