Updates to PrerenderingOffliner and PrerenderingLoader interfaces to push PrerenderManager knowledge

chrome/browser/android/offline_pages/prerendering_offliner_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/prerendering_offliner.h"
+
+#include <memory>
+
+#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 {

[fgorski, 2016/05/09 20:38:32]

can you put this in the anonymous namespace too?

[dougarnett, 2016/05/09 22:25:11]

Done.

+ 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 {

[fgorski, 2016/05/09 20:38:32]

ditto for namespace.

[fgorski, 2016/05/09 20:38:32]

When you have SetLoaderForTesting I don't think this is needed.

[dougarnett, 2016/05/09 22:25:11]

Done.

[dougarnett, 2016/05/09 22:25:11]

Done.

+ 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_.get(); }
+  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);
+
+  std::unique_ptr<PrerenderingOffliner> offliner_;
+  std::unique_ptr<MockPrerenderingLoader> loader_;

[fgorski, 2016/05/09 20:38:32]

this frees the loader memory or the second time. Perhaps that is why you crash.

[dougarnett, 2016/05/09 22:25:11]

reworked

+  Offliner::CompletionStatus completion_status_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrerenderingOfflinerTest);
+};
+
+PrerenderingOfflinerTest::PrerenderingOfflinerTest() {}
+
+PrerenderingOfflinerTest::~PrerenderingOfflinerTest() {}
+
+void PrerenderingOfflinerTest::SetUp() {
+  loader_.reset(new MockPrerenderingLoader(nullptr));

[fgorski, 2016/05/09 20:38:32]

simply create a unique ptr and move it into the offliner_

[dougarnett, 2016/05/09 22:25:11]

Done.

+  offliner_.reset(
+      new TestPrerenderingOffliner(nullptr, nullptr, nullptr, loader_.get()));
+}
+
+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