Split Android-specific dependency from BackgroundLoaderOffliner. Create a subfolder of c/b/offline_…

chrome/browser/offline_pages/background_loader_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/offline_pages/background_loader_offliner.h"
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/scoped_mock_time_message_loop_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/offline_pages/offliner_helper.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/offline_pages/content/background_loader/background_loader_contents_stub.h"
+#include "components/offline_pages/core/background/load_termination_listener.h"
 #include "components/offline_pages/core/background/offliner.h"
 #include "components/offline_pages/core/background/offliner_policy.h"
 #include "components/offline_pages/core/background/save_page_request.h"
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/stub_offline_page_model.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/mhtml_extra_parts.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/web_contents_tester.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 
 const int64_t kRequestId = 7;
 const GURL kHttpUrl("http://www.tunafish.com");
 const GURL kFileUrl("file://salmon.png");
 const ClientId kClientId("async_loading", "88");
 const bool kUserRequested = true;
 
+class TestLoadTerminationListener : public LoadTerminationListener {
+ public:
+  TestLoadTerminationListener() = default;
+  ~TestLoadTerminationListener() override = default;
+
+  void TerminateLoad() { offliner()->TerminateLoadIfInProgress(); }
+
+  Offliner* offliner() { return offliner_; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestLoadTerminationListener);
+};
+
 // Mock OfflinePageModel for testing the SavePage calls
 class MockOfflinePageModel : public StubOfflinePageModel {
  public:
   MockOfflinePageModel() : mock_saving_(false), mock_deleting_(false) {}
   ~MockOfflinePageModel() override {}
 
   void SavePage(const SavePageParams& save_page_params,
                 std::unique_ptr<OfflinePageArchiver> archiver,
                 const SavePageCallback& callback) override {
     mock_saving_ = true;
@@ skipping 46 matching lines @@
 // A BackgroundLoader that we can run tests on.
 // Overrides the ResetState so we don't actually try to create any web contents.
 // This is a temporary solution to test core BackgroundLoaderOffliner
 // functionality until we straighten out assumptions made by RequestCoordinator
 // so that the ResetState method is no longer needed.
 class TestBackgroundLoaderOffliner : public BackgroundLoaderOffliner {
  public:
   explicit TestBackgroundLoaderOffliner(
       content::BrowserContext* browser_context,
       const OfflinerPolicy* policy,
-      OfflinePageModel* offline_page_model);
+      OfflinePageModel* offline_page_model,
+      std::unique_ptr<LoadTerminationListener> load_termination_listener);
   ~TestBackgroundLoaderOffliner() override;
   content::WebContentsTester* web_contents_tester() {
     return content::WebContentsTester::For(stub_->web_contents());
   }
 
   content::WebContents* web_contents() { return stub_->web_contents(); }
 
   bool is_loading() { return loader_ && stub_->is_loading(); }
 
  protected:
   void ResetLoader() override;
 
  private:
   background_loader::BackgroundLoaderContentsStub* stub_;
 };
 
 TestBackgroundLoaderOffliner::TestBackgroundLoaderOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
-    OfflinePageModel* offline_page_model)
-    : BackgroundLoaderOffliner(browser_context, policy, offline_page_model) {}
+    OfflinePageModel* offline_page_model,
+    std::unique_ptr<LoadTerminationListener> load_termination_listener)
+    : BackgroundLoaderOffliner(browser_context,
+                               policy,
+                               offline_page_model,
+                               std::move(load_termination_listener)) {}
 
 TestBackgroundLoaderOffliner::~TestBackgroundLoaderOffliner() {}
 
 void TestBackgroundLoaderOffliner::ResetLoader() {
   stub_ = new background_loader::BackgroundLoaderContentsStub(browser_context_);
   loader_.reset(stub_);
 }
 
 class BackgroundLoaderOfflinerTest : public testing::Test {
  public:
@@ skipping 18 matching lines @@
   Profile* profile() { return &profile_; }
   bool completion_callback_called() { return completion_callback_called_; }
   Offliner::RequestStatus request_status() { return request_status_; }
   bool cancel_callback_called() { return cancel_callback_called_; }
   bool SaveInProgress() const { return model_->mock_saving(); }
   bool DeleteCalled() const { return model_->mock_deleting(); }
   MockOfflinePageModel* model() const { return model_; }
   const base::HistogramTester& histograms() const { return histogram_tester_; }
   int64_t progress() { return progress_; }
   OfflinerPolicy* policy() const { return policy_.get(); }
+  TestLoadTerminationListener* load_termination_listener() {
+    return load_termination_listener_;
+  }
 
   void PumpLoop() { base::RunLoop().RunUntilIdle(); }
 
   void CompleteLoading() {
     // Reset snapshot controller.
     std::unique_ptr<SnapshotController> snapshot_controller(
         new SnapshotController(base::ThreadTaskRunnerHandle::Get(),
                                offliner_.get(),
                                0L /* DelayAfterDocumentAvailable */,
                                0L /* DelayAfterDocumentOnLoad */,
                                false /* DocumentAvailableTriggersSnapshot */));
     offliner_->SetSnapshotControllerForTest(std::move(snapshot_controller));
     // Call complete loading.
     offliner()->DocumentOnLoadCompletedInMainFrame();
     PumpLoop();
   }
 
  private:
   void OnCompletion(const SavePageRequest& request,
                     Offliner::RequestStatus status);
   void OnProgress(const SavePageRequest& request, int64_t bytes);
   void OnCancel(const SavePageRequest& request);
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<OfflinerPolicy> policy_;
+  TestLoadTerminationListener* load_termination_listener_;
   std::unique_ptr<TestBackgroundLoaderOffliner> offliner_;
   MockOfflinePageModel* model_;
   bool completion_callback_called_;
   bool cancel_callback_called_;
   int64_t progress_;
   Offliner::RequestStatus request_status_;
   base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundLoaderOfflinerTest);
 };
 
 BackgroundLoaderOfflinerTest::BackgroundLoaderOfflinerTest()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+      load_termination_listener_(nullptr),
+      model_(nullptr),
       completion_callback_called_(false),
       cancel_callback_called_(false),
       progress_(0LL),
       request_status_(Offliner::RequestStatus::UNKNOWN) {}
 
 BackgroundLoaderOfflinerTest::~BackgroundLoaderOfflinerTest() {}
 
 void BackgroundLoaderOfflinerTest::SetUp() {
+  std::unique_ptr<TestLoadTerminationListener> listener =
+      base::MakeUnique<TestLoadTerminationListener>();
+  load_termination_listener_ = listener.get();
   model_ = new MockOfflinePageModel();
   policy_.reset(new OfflinerPolicy());
-  offliner_.reset(
-      new TestBackgroundLoaderOffliner(profile(), policy_.get(), model_));
+  offliner_.reset(new TestBackgroundLoaderOffliner(
+      profile(), policy_.get(), model_, std::move(listener)));
 }
 
 void BackgroundLoaderOfflinerTest::OnCompletion(
     const SavePageRequest& request,
     Offliner::RequestStatus status) {
   DCHECK(!completion_callback_called_);  // Expect 1 callback per request.
   completion_callback_called_ = true;
   request_status_ = status;
 }
 
 void BackgroundLoaderOfflinerTest::OnProgress(const SavePageRequest& request,
                                               int64_t bytes) {
   progress_ = bytes;
 }
 
 void BackgroundLoaderOfflinerTest::OnCancel(const SavePageRequest& request) {
   DCHECK(!cancel_callback_called_);
   cancel_callback_called_ = true;
 }
 
 // Two tests crash roughly 20% of runs on Android.  http://crbug.com/722556.
 #if defined(OS_ANDROID)
 #define MAYBE_FailsOnErrorPage DISABLED_FailsOnErrorPage
 #define MAYBE_NoNextOnInternetDisconnected DISABLED_NoNextOnInternetDisconnected
 #else
 #define MAYBE_FailsOnErrorPage FailsOnErrorPage
 #define MAYBE_NoNextOnInternetDisconnected NoNextOnInternetDisconnected
 #endif
 
+TEST_F(BackgroundLoaderOfflinerTest, LoadTerminationListenerSetup) {
+  // Verify that back pointer to offliner is set up in the listener.
+  Offliner* base_offliner = offliner();
+  EXPECT_NE(base_offliner, nullptr);
+  EXPECT_EQ(base_offliner, load_termination_listener()->offliner());
+}
+
 TEST_F(BackgroundLoaderOfflinerTest,
        LoadAndSaveBlockThirdPartyCookiesForCustomTabs) {
   base::Time creation_time = base::Time::Now();
   ClientId custom_tabs_client_id("custom_tabs", "88");
   SavePageRequest request(kRequestId, kHttpUrl, custom_tabs_client_id,
                           creation_time, kUserRequested);
 
   profile()->GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, true);
   EXPECT_FALSE(offliner()->LoadAndSave(request, completion_callback(),
                                        progress_callback()));
@@ skipping 74 matching lines @@
   EXPECT_TRUE(offliner()->LoadAndSave(request, completion_callback(),
                                       progress_callback()));
   offliner()->Cancel(cancel_callback());
   PumpLoop();
   offliner()->OnNetworkBytesChanged(15LL);
   EXPECT_TRUE(cancel_callback_called());
   EXPECT_FALSE(offliner()->is_loading());  // Offliner reset.
   EXPECT_EQ(progress(), 0LL);  // network bytes not recorded when not busy.
 }
 
+TEST_F(BackgroundLoaderOfflinerTest, CancelWhenLoadTerminated) {
+  base::Time creation_time = base::Time::Now();
+  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time,
+                          kUserRequested);
+  EXPECT_TRUE(offliner()->LoadAndSave(request, completion_callback(),
+                                      progress_callback()));
+  load_termination_listener()->TerminateLoad();
+  PumpLoop();
+  EXPECT_TRUE(completion_callback_called());
+  EXPECT_FALSE(offliner()->is_loading());  // Offliner reset.
+  EXPECT_EQ(Offliner::RequestStatus::FOREGROUND_CANCELED, request_status());
+}
+
 TEST_F(BackgroundLoaderOfflinerTest, CancelWhenLoaded) {
   base::Time creation_time = base::Time::Now();
   SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time,
                           kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, completion_callback(),
                                       progress_callback()));
   CompleteLoading();
   PumpLoop();
   offliner()->Cancel(cancel_callback());
   PumpLoop();
@@ skipping 297 matching lines @@
   CompleteLoading();
   PumpLoop();
 
   // One extra part should be added if the flag is on.
   content::MHTMLExtraParts* extra_parts =
       content::MHTMLExtraParts::FromWebContents(offliner()->web_contents());
   EXPECT_EQ(extra_parts->size(), 1);
 }
 
 }  // namespace offline_pages