More detailed implementation of the RequestPicker

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 "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/offline_pages/prerendering_loader.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/offline_pages/background/offliner.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/stub_offline_page_model.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 const int64_t kRequestId = 7;
 const GURL kHttpUrl("http://tunafish.com");
 const GURL kFileUrl("file://sailfish.png");
 const ClientId kClientId("AsyncLoading", "88");
+const bool kUserRequested = true;
 
 // Mock Loader for testing the Offliner calls.
 class MockPrerenderingLoader : public PrerenderingLoader {
  public:
   explicit MockPrerenderingLoader(content::BrowserContext* browser_context)
       : PrerenderingLoader(browser_context),
         can_prerender_(true),
         mock_loading_(false),
         mock_loaded_(false) {}
   ~MockPrerenderingLoader() override {}
@@ skipping 153 matching lines @@
 
 void PrerenderingOfflinerTest::OnCompletion(const SavePageRequest& request,
                                             Offliner::RequestStatus status) {
   DCHECK(!completion_callback_called_);  // Expect single callback per request.
   completion_callback_called_ = true;
   request_status_ = status;
 }
 
 TEST_F(PrerenderingOfflinerTest, LoadAndSaveBadUrl) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kFileUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kFileUrl, kClientId, creation_time, kUserRequested);
   EXPECT_FALSE(offliner()->LoadAndSave(request, callback()));
   EXPECT_TRUE(loader()->IsIdle());
 }
 
 TEST_F(PrerenderingOfflinerTest, LoadAndSavePrerenderingDisabled) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kHttpUrl, kClientId, creation_time, kUserRequested);
   loader()->DisablePrerendering();
   EXPECT_FALSE(offliner()->LoadAndSave(request, callback()));
   EXPECT_TRUE(loader()->IsIdle());
 }
 
 TEST_F(PrerenderingOfflinerTest, LoadAndSaveLoadStartedButFails) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kHttpUrl, kClientId, creation_time, kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
   EXPECT_FALSE(loader()->IsIdle());
   EXPECT_EQ(Offliner::RequestStatus::UNKNOWN, request_status());
 
   loader()->CompleteLoadingAsFailed();
   PumpLoop();
   EXPECT_TRUE(completion_callback_called());
   EXPECT_EQ(Offliner::RequestStatus::PRERENDERING_FAILED, request_status());
   EXPECT_TRUE(loader()->IsIdle());
   EXPECT_FALSE(SaveInProgress());
 }
 
 TEST_F(PrerenderingOfflinerTest, CancelWhenLoading) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kHttpUrl, kClientId, creation_time, kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
   EXPECT_FALSE(loader()->IsIdle());
 
   offliner()->Cancel();
   EXPECT_TRUE(loader()->IsIdle());
 }
 
 TEST_F(PrerenderingOfflinerTest, CancelWhenLoaded) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kHttpUrl, kClientId, creation_time, kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
   EXPECT_FALSE(loader()->IsIdle());
   EXPECT_EQ(Offliner::RequestStatus::UNKNOWN, request_status());
 
   loader()->CompleteLoadingAsLoaded();
   PumpLoop();
   EXPECT_FALSE(completion_callback_called());
   EXPECT_TRUE(loader()->IsLoaded());
   EXPECT_TRUE(SaveInProgress());
 
   offliner()->Cancel();
   PumpLoop();
   EXPECT_FALSE(completion_callback_called());
   EXPECT_FALSE(loader()->IsLoaded());
   // Note: save still in progress since it does not support canceling.
   EXPECT_TRUE(SaveInProgress());
 
   // Subsequent save callback causes no harm (no crash and no callback).
   model()->CompleteSavingAsArchiveCreationFailed();
   PumpLoop();
   EXPECT_FALSE(completion_callback_called());
   EXPECT_TRUE(loader()->IsIdle());
   EXPECT_FALSE(SaveInProgress());
 }
 
 TEST_F(PrerenderingOfflinerTest, LoadAndSaveLoadedButSaveFails) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kHttpUrl, kClientId, creation_time, kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
   EXPECT_FALSE(loader()->IsIdle());
   EXPECT_EQ(Offliner::RequestStatus::UNKNOWN, request_status());
 
   loader()->CompleteLoadingAsLoaded();
   PumpLoop();
   EXPECT_FALSE(completion_callback_called());
   EXPECT_TRUE(loader()->IsLoaded());
   EXPECT_TRUE(SaveInProgress());
 
   model()->CompleteSavingAsArchiveCreationFailed();
   PumpLoop();
   EXPECT_TRUE(completion_callback_called());
   EXPECT_EQ(Offliner::RequestStatus::SAVE_FAILED, request_status());
   EXPECT_FALSE(loader()->IsLoaded());
   EXPECT_FALSE(SaveInProgress());
 }
 
 TEST_F(PrerenderingOfflinerTest, LoadAndSaveSuccessful) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kHttpUrl, kClientId, creation_time, kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
   EXPECT_FALSE(loader()->IsIdle());
   EXPECT_EQ(Offliner::RequestStatus::UNKNOWN, request_status());
 
   loader()->CompleteLoadingAsLoaded();
   PumpLoop();
   EXPECT_FALSE(completion_callback_called());
   EXPECT_TRUE(loader()->IsLoaded());
   EXPECT_TRUE(SaveInProgress());
 
   model()->CompleteSavingAsSuccess();
   PumpLoop();
   EXPECT_TRUE(completion_callback_called());
   EXPECT_EQ(Offliner::RequestStatus::SAVED, request_status());
   EXPECT_FALSE(loader()->IsLoaded());
   EXPECT_FALSE(SaveInProgress());
 }
 
 TEST_F(PrerenderingOfflinerTest, LoadAndSaveLoadedButThenCanceledFromLoader) {
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time);
+  SavePageRequest request(
+      kRequestId, kHttpUrl, kClientId, creation_time, kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
   EXPECT_FALSE(loader()->IsIdle());
   EXPECT_EQ(Offliner::RequestStatus::UNKNOWN, request_status());
 
   loader()->CompleteLoadingAsLoaded();
   PumpLoop();
   EXPECT_FALSE(completion_callback_called());
   EXPECT_TRUE(loader()->IsLoaded());
   EXPECT_TRUE(SaveInProgress());
 
   loader()->CompleteLoadingAsCanceled();
   PumpLoop();
   EXPECT_TRUE(completion_callback_called());
   EXPECT_EQ(Offliner::RequestStatus::PRERENDERING_CANCELED, request_status());
   EXPECT_FALSE(loader()->IsLoaded());
   // Note: save still in progress since it does not support canceling.
   EXPECT_TRUE(SaveInProgress());
 }
 
 }  // namespace offline_pages