Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

chrome/browser/android/offline_pages/recent_tab_helper_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/recent_tab_helper.h"
 
+#include <memory>
+
 #include "base/memory/ptr_util.h"
-#include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/scoped_feature_list.h"
-#include "base/test/test_mock_time_task_runner.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/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/request_coordinator_factory.h"
 #include "chrome/browser/android/offline_pages/test_offline_page_model_builder.h"
 #include "chrome/browser/android/offline_pages/test_request_coordinator_builder.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/offline_page_item.h"
 #include "components/offline_pages/core/offline_page_model.h"
@@ skipping 13 matching lines @@
 const GURL kTestPageUrlOther("http://crazy.site/foo_other.html");
 const int kTabId = 153;
 }  // namespace
 
 class TestDelegate: public RecentTabHelper::Delegate {
  public:
   const size_t kArchiveSizeToReport = 1234;
 
   explicit TestDelegate(
       OfflinePageTestArchiver::Observer* observer,
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       int tab_id,
       bool tab_id_result);
   ~TestDelegate() override {}
 
   std::unique_ptr<OfflinePageArchiver> CreatePageArchiver(
         content::WebContents* web_contents) override;
-  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override;
     // There is no expectations that tab_id is always present.
   bool GetTabId(content::WebContents* web_contents, int* tab_id) override;
   bool IsLowEndDevice() override { return is_low_end_device_; }
 
   void set_archive_result(
       offline_pages::OfflinePageArchiver::ArchiverResult result) {
     archive_result_ = result;
   }
 
   void set_archive_size(int64_t size) { archive_size_ = size; }
 
   void SetAsLowEndDevice() { is_low_end_device_ = true; }
 
  private:
   OfflinePageTestArchiver::Observer* observer_;  // observer owns this.
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   int tab_id_;
   bool tab_id_result_;
 
   // These values can be updated so that new OfflinePageTestArchiver instances
   // will return different results.
   offline_pages::OfflinePageArchiver::ArchiverResult archive_result_ =
       offline_pages::OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED;
   int64_t archive_size_ = kArchiveSizeToReport;
   bool is_low_end_device_ = false;
 };
 
 class RecentTabHelperTest
     : public ChromeRenderViewHostTestHarness,
       public OfflinePageModel::Observer,
       public OfflinePageTestArchiver::Observer {
  public:
   RecentTabHelperTest();
   ~RecentTabHelperTest() override {}
 
   void SetUp() override;
+  void TearDown() override;
   const std::vector<OfflinePageItem>& GetAllPages();
 
   void FailLoad(const GURL& url);
 
-  // Runs default thread.
+  // Runs main thread.
   void RunUntilIdle();
-  // Moves forward the snapshot controller's task runner.
+  // Advances main thread time to trigger the snapshot controller's timeouts.
   void FastForwardSnapshotController();
 
   // Navigates to the URL and commit as if it has been typed in the address bar.
   // Note: we need this to simulate navigations to the same URL that more like a
   // reload and not same page. NavigateAndCommit simulates a click on a link
   // and when reusing the same URL that will be considered a same page
   // navigation.
   void NavigateAndCommitTyped(const GURL& url);
 
   ClientId NewDownloadClientId();
 
   RecentTabHelper* recent_tab_helper() const { return recent_tab_helper_; }
 
   OfflinePageModel* model() const { return model_; }
 
   TestDelegate* default_test_delegate() { return default_test_delegate_; }
 
   // Returns a OfflinePageItem pointer from |all_pages| that matches the
   // provided |offline_id|. If a match is not found returns nullptr.
   const OfflinePageItem* FindPageForOfflineId(int64_t offline_id) {
     for (const OfflinePageItem& page : GetAllPages()) {
       if (page.offline_id == offline_id)
         return &page;
     }
     return nullptr;
   }
 
-  scoped_refptr<base::TestMockTimeTaskRunner>& task_runner() {
-    return task_runner_;
-  }
-
   size_t page_added_count() { return page_added_count_; }
   size_t model_removed_count() { return model_removed_count_; }
 
   // OfflinePageModel::Observer
   void OfflinePageModelLoaded(OfflinePageModel* model) override {
     all_pages_needs_updating_ = true;
   }
   void OfflinePageAdded(OfflinePageModel* model,
                         const OfflinePageItem& added_page) override {
     page_added_count_++;
@@ skipping 10 matching lines @@
  private:
   void OnGetAllPagesDone(const std::vector<OfflinePageItem>& result);
 
   RecentTabHelper* recent_tab_helper_;   // Owned by WebContents.
   OfflinePageModel* model_;              // Keyed service.
   TestDelegate* default_test_delegate_;  // Created at SetUp.
   size_t page_added_count_;
   size_t model_removed_count_;
   std::vector<OfflinePageItem> all_pages_;
   bool all_pages_needs_updating_;
-  scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::test::ScopedFeatureList scoped_feature_list_;
 
+  // Mocks the RenderViewHostTestHarness' main thread runner. Needs to be delay
+  // initialized in SetUp() -- can't be a simple member -- since
+  // RenderViewHostTestHarness only initializes its main thread environment in
+  // its SetUp() :(.
+  std::unique_ptr<base::ScopedMockTimeMessageLoopTaskRunner>
+      mocked_main_runner_;
+
   base::WeakPtrFactory<RecentTabHelperTest> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RecentTabHelperTest);
 };
 
 TestDelegate::TestDelegate(
     OfflinePageTestArchiver::Observer* observer,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     int tab_id,
     bool tab_id_result)
     : observer_(observer),
-      task_runner_(task_runner),
       tab_id_(tab_id),
       tab_id_result_(tab_id_result) {
 }
 
 std::unique_ptr<OfflinePageArchiver> TestDelegate::CreatePageArchiver(
     content::WebContents* web_contents) {
   std::unique_ptr<OfflinePageTestArchiver> archiver(new OfflinePageTestArchiver(
       observer_, web_contents->GetLastCommittedURL(), archive_result_,
       base::string16(), kArchiveSizeToReport,
       base::ThreadTaskRunnerHandle::Get()));
   return std::move(archiver);
 }
 
-scoped_refptr<base::SingleThreadTaskRunner> TestDelegate::GetTaskRunner() {
-  return task_runner_;
-}
-  // There is no expectations that tab_id is always present.
+// There is no expectations that tab_id is always present.
 bool TestDelegate::GetTabId(content::WebContents* web_contents, int* tab_id) {
   *tab_id = tab_id_;
   return tab_id_result_;
 }
 
 RecentTabHelperTest::RecentTabHelperTest()
     : recent_tab_helper_(nullptr),
       model_(nullptr),
       default_test_delegate_(nullptr),
       page_added_count_(0),
       model_removed_count_(0),
       all_pages_needs_updating_(true),
-      task_runner_(new base::TestMockTimeTaskRunner),
       weak_ptr_factory_(this) {}
 
 void RecentTabHelperTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
 
+  mocked_main_runner_ =
+      base::MakeUnique<base::ScopedMockTimeMessageLoopTaskRunner>();
+
   scoped_feature_list_.InitAndEnableFeature(kOffliningRecentPagesFeature);
   // Sets up the factories for testing.
   OfflinePageModelFactory::GetInstance()->SetTestingFactoryAndUse(
       browser_context(), BuildTestOfflinePageModel);
   RunUntilIdle();
   RequestCoordinatorFactory::GetInstance()->SetTestingFactoryAndUse(
       browser_context(), BuildTestRequestCoordinator);
   RunUntilIdle();
 
   RecentTabHelper::CreateForWebContents(web_contents());
   recent_tab_helper_ = RecentTabHelper::FromWebContents(web_contents());
 
   std::unique_ptr<TestDelegate> test_delegate(
-      new TestDelegate(this, task_runner(), kTabId, true));
+      new TestDelegate(this, kTabId, true));
   default_test_delegate_ = test_delegate.get();
   recent_tab_helper_->SetDelegate(std::move(test_delegate));
 
   model_ = OfflinePageModelFactory::GetForBrowserContext(browser_context());
   model_->AddObserver(this);
 }
 
+void RecentTabHelperTest::TearDown() {
+  mocked_main_runner_.reset();
+  ChromeRenderViewHostTestHarness::TearDown();
+}
+
 void RecentTabHelperTest::FailLoad(const GURL& url) {
   controller().LoadURL(url, content::Referrer(), ui::PAGE_TRANSITION_TYPED,
                        std::string());
   content::RenderFrameHostTester::For(main_rfh())->SimulateNavigationStart(url);
   content::RenderFrameHostTester::For(main_rfh())->
       SimulateNavigationError(url, net::ERR_INTERNET_DISCONNECTED);
   content::RenderFrameHostTester::For(main_rfh())->
       SimulateNavigationErrorPageCommit();
 }
 
 const std::vector<OfflinePageItem>& RecentTabHelperTest::GetAllPages() {
   if (all_pages_needs_updating_) {
     model()->GetAllPages(base::Bind(&RecentTabHelperTest::OnGetAllPagesDone,
                                     weak_ptr_factory_.GetWeakPtr()));
     RunUntilIdle();
     all_pages_needs_updating_ = false;
   }
   return all_pages_;
 }
 
 void RecentTabHelperTest::OnGetAllPagesDone(
     const std::vector<OfflinePageItem>& result) {
   all_pages_ = result;
 }
 
 void RecentTabHelperTest::RunUntilIdle() {
-  base::RunLoop().RunUntilIdle();
+  (*mocked_main_runner_)->RunUntilIdle();
 }
 
 void RecentTabHelperTest::FastForwardSnapshotController() {
-  const size_t kLongDelayMs = 100*1000;
-  task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(kLongDelayMs));
+  constexpr base::TimeDelta kLongDelay = base::TimeDelta::FromSeconds(100);
+  (*mocked_main_runner_)->FastForwardBy(kLongDelay);
 }
 
 void RecentTabHelperTest::NavigateAndCommitTyped(const GURL& url) {
   controller().LoadURL(url, content::Referrer(), ui::PAGE_TRANSITION_TYPED,
                        std::string());
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->CommitPendingNavigation();
 }
 
@@ skipping 11 matching lines @@
 }
 
 // Fully loads a page then simulates the tab being hidden. Verifies that a
 // snapshot is created only when the latter happens.
 TEST_F(RecentTabHelperTest, LastNCaptureAfterLoad) {
   // Navigate and finish loading. Nothing should be saved.
   NavigateAndCommit(kTestPageUrl);
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   EXPECT_EQ(0U, page_added_count());
   ASSERT_EQ(0U, GetAllPages().size());
 
   // Tab is hidden with a fully loaded page. A snapshot save should happen.
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   EXPECT_EQ(1U, page_added_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrl, GetAllPages()[0].url);
   EXPECT_EQ(kLastNNamespace, GetAllPages()[0].client_id.name_space);
 }
 
 // Simulates the tab being hidden too early in the page loading so that a
 // snapshot should not be created.
 TEST_F(RecentTabHelperTest, NoLastNCaptureIfTabHiddenTooEarlyInPageLoad) {
   // Commit the navigation and hide the tab. Nothing should be saved.
   NavigateAndCommit(kTestPageUrl);
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   EXPECT_EQ(0U, page_added_count());
   ASSERT_EQ(0U, GetAllPages().size());
 
   // Then allow the page to fully load. Nothing should be saved.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_EQ(0U, page_added_count());
   ASSERT_EQ(0U, GetAllPages().size());
 }
 
 // Checks that WebContents with no tab IDs have snapshot requests properly
 // ignored from both last_n and downloads.
 TEST_F(RecentTabHelperTest, NoTabIdNoCapture) {
   // Create delegate that returns 'false' as TabId retrieval result.
-  recent_tab_helper()->SetDelegate(base::MakeUnique<TestDelegate>(
-      this, task_runner(), kTabId, false));
+  recent_tab_helper()->SetDelegate(
+      base::MakeUnique<TestDelegate>(this, kTabId, false));
 
   NavigateAndCommit(kTestPageUrl);
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
   recent_tab_helper()->WasHidden();
   recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                      123L);
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   // No page should be captured.
@@ skipping 25 matching lines @@
   ASSERT_EQ(1U, GetAllPages().size());
 }
 
 // Triggers two last_n snapshot captures during a single page load. Should end
 // up with one snapshot, the 1st being replaced by the 2nd.
 TEST_F(RecentTabHelperTest, TwoCapturesSamePageLoad) {
   NavigateAndCommit(kTestPageUrl);
   // Set page loading state to the 1st snapshot-able stage. No capture so far.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   EXPECT_EQ(0U, page_added_count());
 
   // Tab is hidden and a snapshot should be saved.
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrl, GetAllPages()[0].url);
   int64_t first_offline_id = GetAllPages()[0].offline_id;
 
   // Set page loading state to the 2nd and last snapshot-able stage. No new
   // capture should happen.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
 
   // Tab is hidden again. At this point a higher quality snapshot is expected so
   // a new one should be captured and replace the previous one.
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
@@ skipping 52 matching lines @@
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrl, GetAllPages()[0].url);
   int64_t first_offline_id = GetAllPages()[0].offline_id;
 
   // Navigate with the same URL until the page is minimally loaded then hide the
   // tab. The previous snapshot should be removed and a new one taken.
   NavigateAndCommitTyped(kTestPageUrl);
   recent_tab_helper()->DocumentAvailableInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
 
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrl, GetAllPages()[0].url);
@@ skipping 45 matching lines @@
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrl, GetAllPages()[0].url);
 
   // Fully load the second URL then hide the tab and check for a single snapshot
   // of the new page.
   NavigateAndCommitTyped(kTestPageUrlOther);
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
 
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrlOther, GetAllPages()[0].url);
@@ skipping 90 matching lines @@
 
 // Simulates a download request to offline the current page made early during
 // loading. Should execute two captures but only the final one is kept.
 TEST_F(RecentTabHelperTest, DownloadRequestEarlyInLoad) {
   // Commit the navigation and request the snapshot from downloads. No captures
   // so far.
   NavigateAndCommit(kTestPageUrl);
   const ClientId client_id = NewDownloadClientId();
   recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, 153L);
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   ASSERT_EQ(0U, GetAllPages().size());
 
   // Minimally load the page. First capture should occur.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   ASSERT_EQ(1U, GetAllPages().size());
   const OfflinePageItem& early_page = GetAllPages()[0];
   EXPECT_EQ(kTestPageUrl, early_page.url);
   EXPECT_EQ(client_id, early_page.client_id);
   EXPECT_EQ(153L, early_page.offline_id);
 
   // Fully load the page. A second capture should replace the first one.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   const OfflinePageItem& later_page = GetAllPages()[0];
   EXPECT_EQ(kTestPageUrl, later_page.url);
   EXPECT_EQ(client_id, later_page.client_id);
   EXPECT_EQ(153L, later_page.offline_id);
 }
 
 // Simulates a download request to offline the current page made when the page
 // is minimally loaded. Should execute two captures but only the final one is
 // kept.
 TEST_F(RecentTabHelperTest, DownloadRequestLaterInLoad) {
   NavigateAndCommit(kTestPageUrl);
   recent_tab_helper()->DocumentAvailableInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   ASSERT_EQ(0U, GetAllPages().size());
 
   const ClientId client_id = NewDownloadClientId();
   recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, 153L);
   RunUntilIdle();
   ASSERT_EQ(1U, GetAllPages().size());
   const OfflinePageItem& page = GetAllPages()[0];
   EXPECT_EQ(kTestPageUrl, page.url);
   EXPECT_EQ(client_id, page.client_id);
   EXPECT_EQ(153L, page.offline_id);
 
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
 }
 
 // Simulates a download request to offline the current page made after loading
 // is completed. Should end up with one offline pages.
 TEST_F(RecentTabHelperTest, DownloadRequestAfterFullyLoad) {
   NavigateAndCommit(kTestPageUrl);
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   ASSERT_EQ(0U, GetAllPages().size());
 
   const ClientId client_id = NewDownloadClientId();
   recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id, 153L);
   RunUntilIdle();
   ASSERT_EQ(1U, GetAllPages().size());
   const OfflinePageItem& page = GetAllPages()[0];
   EXPECT_EQ(kTestPageUrl, page.url);
   EXPECT_EQ(client_id, page.client_id);
@@ skipping 69 matching lines @@
   NavigateAndCommit(kTestPageUrl);
   const ClientId client_id_1 = NewDownloadClientId();
   const int64_t offline_id_1 = 153L;
   recent_tab_helper()->ObserveAndDownloadCurrentPage(client_id_1, offline_id_1);
   recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                      351L);
 
   // Finish loading the page. Only the first request should be executed.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
-  RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   const OfflinePageItem& fist_page = GetAllPages()[0];
   EXPECT_EQ(client_id_1, fist_page.client_id);
   EXPECT_EQ(offline_id_1, fist_page.offline_id);
 
   // Make two additional download snapshot requests. Again only the first should
   // generate a snapshot.
   const ClientId client_id_3 = NewDownloadClientId();
@@ skipping 74 matching lines @@
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
 }
 
 }  // namespace offline_pages