Updates to PrerenderingOffliner and PrerenderingLoader interfaces to push PrerenderManager knowledge

chrome/browser/android/offline_pages/prerendering_offliner_unittest.cc

Index: chrome/browser/android/offline_pages/prerendering_offliner_unittest.cc
diff --git a/chrome/browser/android/offline_pages/prerendering_offliner_unittest.cc b/chrome/browser/android/offline_pages/prerendering_offliner_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..46cac405b727591cb8de9a1794ece254e204fadb
--- /dev/null
+++ b/chrome/browser/android/offline_pages/prerendering_offliner_unittest.cc
@@ -0,0 +1,128 @@
+// 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_offliner.h"
+
+#include "base/bind.h"
+#include "chrome/browser/android/offline_pages/prerendering_loader.h"
+#include "components/offline_pages/background/offliner.h"
+#include "components/offline_pages/background/save_page_request.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace offline_pages {
+
+// Mock Loader for testing the Offliner calls.
+class MockPrerenderingLoader : public PrerenderingLoader {

[Pete Williamson, 2016/05/09 16:49:38]

Is there any other class that might need the MockPrerenderingLoader?  I suspect
not, but if so, consider moving this class to its own file.

[dougarnett, 2016/05/09 17:42:04]

At this point I see it as private to Offliner but we may add some test framework
support to drive testing of loading pages and testing that test framework may
motivate breaking it out. Would prefer to wait until and if we do integrate at
the Loader level though.

+ public:
+  explicit MockPrerenderingLoader(content::BrowserContext* browser_context)
+      : PrerenderingLoader(browser_context), mock_loading_(false) {}
+  ~MockPrerenderingLoader() override {}
+
+  bool LoadPage(const GURL& url, const LoadPageCallback& callback) override {
+    mock_loading_ = true;
+    return mock_loading_;
+  }
+
+  void StopLoading() override { mock_loading_ = false; }
+
+  bool mock_loading() const { return mock_loading_; }
+
+ private:
+  bool mock_loading_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockPrerenderingLoader);
+};
+
+// Test subclass that injects loader.
+class TestPrerenderingOffliner : public PrerenderingOffliner {
+ public:
+  TestPrerenderingOffliner(content::BrowserContext* browser_context,
+                           const OfflinerPolicy* policy,
+                           OfflinePageModel* offline_page_model,
+                           PrerenderingLoader* loader)
+      : PrerenderingOffliner(browser_context,
+                             policy,
+                             offline_page_model,
+                             loader) {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestPrerenderingOffliner);
+};
+
+namespace {
+const int64_t kRequestId = 7;
+const GURL kHttpUrl("http://tunafish.com");
+const GURL kFileUrl("file://sailfish.png");
+const ClientId kClientId("AsyncLoading", "88");
+}  // namespace
+
+class PrerenderingOfflinerTest : public testing::Test {
+ public:
+  PrerenderingOfflinerTest();
+  ~PrerenderingOfflinerTest() override;
+
+  void SetUp() override;
+
+  PrerenderingOffliner* offliner() const { return offliner_; }
+  Offliner::CompletionCallback callback() {
+    return base::Bind(&PrerenderingOfflinerTest::OnCompletion,
+                      base::Unretained(this));
+  }
+
+  bool loading() const { return loader_->mock_loading(); }
+  Offliner::CompletionStatus completion_status() { return completion_status_; }
+
+ private:
+  void OnCompletion(const SavePageRequest& request,
+                    Offliner::CompletionStatus status);
+
+  PrerenderingOffliner* offliner_;

[Pete Williamson, 2016/05/09 16:49:38]

How do these get destroyed?

[dougarnett, 2016/05/09 17:42:04]

Done.

+  MockPrerenderingLoader* loader_;
+  Offliner::CompletionStatus completion_status_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrerenderingOfflinerTest);
+};
+
+PrerenderingOfflinerTest::PrerenderingOfflinerTest() {}
+
+PrerenderingOfflinerTest::~PrerenderingOfflinerTest() {}
+
+void PrerenderingOfflinerTest::SetUp() {
+  loader_ = new MockPrerenderingLoader(nullptr);
+  offliner_ = new TestPrerenderingOffliner(nullptr, nullptr, nullptr, loader_);
+}
+
+void PrerenderingOfflinerTest::OnCompletion(const SavePageRequest& request,
+                                            Offliner::CompletionStatus status) {
+  completion_status_ = status;
+}
+
+// Tests initiate loading.
+TEST_F(PrerenderingOfflinerTest, LoadAndSaveBadUrl) {
+  base::Time creation_time = base::Time::Now();
+  SavePageRequest request(kRequestId, kFileUrl, kClientId, creation_time);
+  EXPECT_FALSE(offliner()->LoadAndSave(request, callback()));
+  EXPECT_FALSE(loading());
+}
+
+// Tests initiate loading.
+TEST_F(PrerenderingOfflinerTest, LoadAndSaveStartsLoading) {
+  base::Time creation_time = base::Time::Now();
+  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
+  EXPECT_TRUE(loading());
+}
+
+// Tests cancels loading.
+TEST_F(PrerenderingOfflinerTest, CancelLoading) {
+  base::Time creation_time = base::Time::Now();
+  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
+  EXPECT_TRUE(loading());
+
+  offliner()->Cancel();
+  EXPECT_FALSE(loading());
+}
+
+}  // namespace offline_pages