Offline Pages: Replace Observer::OfflinePageModelChanged with OfflinePageAdded.

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 "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/test/scoped_feature_list.h"
@@ skipping 77 matching lines @@
   RecentTabHelper* recent_tab_helper() const { return recent_tab_helper_; }
 
   OfflinePageModel* model() const { return model_; }
 
   const std::vector<OfflinePageItem>& all_pages() { return all_pages_; }
 
   scoped_refptr<base::TestMockTimeTaskRunner>& task_runner() {
     return task_runner_;
   }
 
-  size_t model_changed_count() { return model_changed_count_; }
+  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 { }
-  void OfflinePageModelChanged(OfflinePageModel* model) override {
-    model_changed_count_++;
+  void OfflinePageAdded(OfflinePageModel* model,
+                        const OfflinePageItem& added_page) override {
+    page_added_count_++;
   }
   void OfflinePageDeleted(int64_t, const offline_pages::ClientId&) override {
     model_removed_count_++;
   }
 
   // OfflinePageTestArchiver::Observer
   void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override {}
 
  private:
   void OnGetAllPagesDone(const std::vector<OfflinePageItem>& result);
 
   RecentTabHelper* recent_tab_helper_;  // Owned by WebContents.
   OfflinePageModel* model_;  // Keyed service
-  size_t model_changed_count_;
+  size_t page_added_count_;
   size_t model_removed_count_;
   std::vector<OfflinePageItem> all_pages_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::test::ScopedFeatureList scoped_feature_list_;
 
   base::WeakPtrFactory<RecentTabHelperTest> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RecentTabHelperTest);
 };
 
@@ skipping 22 matching lines @@
 }
   // 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),
-      model_changed_count_(0),
+      page_added_count_(0),
       model_removed_count_(0),
       task_runner_(new base::TestMockTimeTaskRunner),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 void RecentTabHelperTest::SetUp() {
   content::RenderViewHostTestHarness::SetUp();
 
   scoped_feature_list_.InitAndEnableFeature(kOffliningRecentPagesFeature);
   // Sets up the factory for testing.
   OfflinePageModelFactory::GetInstance()->SetTestingFactoryAndUse(
       browser_context(), BuildTestOfflinePageModel);
   RunUntilIdle();
 
@@ skipping 76 matching lines @@
 }
 
 // Triggers two snapshot captures during a single page load. Should end up with
 // one offline page (the 2nd snapshot should be kept).
 TEST_F(RecentTabHelperTest, TwoCapturesSamePageLoad) {
   NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
-  EXPECT_EQ(0U, model_changed_count());
+  EXPECT_EQ(0U, page_added_count());
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(1U, model_changed_count());
+  EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
   int64_t first_offline_id = all_pages()[0].offline_id;
 
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(2U, model_changed_count());
+  EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   // the same page should be simply overridden.
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
   EXPECT_NE(first_offline_id, all_pages()[0].offline_id);
 }
 
 // Triggers two snapshot captures during a single page load, where the 2nd one
 // fails. Should end up with one offline page (the 1st, successful snapshot
 // should be kept).
 TEST_F(RecentTabHelperTest, TwoCapturesSamePageLoadSecondFails) {
   NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
-  EXPECT_EQ(0U, model_changed_count());
+  EXPECT_EQ(0U, page_added_count());
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(1U, model_changed_count());
+  EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
   int64_t first_offline_id = all_pages()[0].offline_id;
 
   // Sets a new delegate that will make the second snapshot fail.
   TestDelegate* failing_delegate =
       new TestDelegate(this, task_runner(), kTabId, true);
   failing_delegate->set_archive_size(-1);
   failing_delegate->set_archive_result(
       offline_pages::OfflinePageArchiver::ArchiverResult::
           ERROR_ARCHIVE_CREATION_FAILED);
   recent_tab_helper()->SetDelegate(
       std::unique_ptr<TestDelegate>(failing_delegate));
 
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(1U, model_changed_count());
+  EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   // The exact same page should still be available.
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
   EXPECT_EQ(first_offline_id, all_pages()[0].offline_id);
 }
 
 // Triggers two snapshot captures for two different page loads for the same URL.
 // Should end up with one offline page (snapshot from the 2nd load).
 TEST_F(RecentTabHelperTest, TwoCapturesDifferentPageLoadsSameUrl) {
   NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
-  EXPECT_EQ(0U, model_changed_count());
+  EXPECT_EQ(0U, page_added_count());
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(1U, model_changed_count());
+  EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
   int64_t first_offline_id = all_pages()[0].offline_id;
 
   NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(2U, model_changed_count());
+  EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   // the same page should be simply overridden.
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
   EXPECT_NE(first_offline_id, all_pages()[0].offline_id);
 }
 
 // Triggers two snapshot captures for two different page loads for the same URL,
 // where the 2nd one fails. Should end up with no offline pages (privacy driven
 // decision).
 TEST_F(RecentTabHelperTest, TwoCapturesDifferentPageLoadsSameUrlSecondFails) {
   NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
-  EXPECT_EQ(0U, model_changed_count());
+  EXPECT_EQ(0U, page_added_count());
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(1U, model_changed_count());
+  EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
 
   // Sets a new delegate that will make the second snapshot fail.
   TestDelegate* failing_delegate =
       new TestDelegate(this, task_runner(), kTabId, true);
   failing_delegate->set_archive_size(-1);
   failing_delegate->set_archive_result(
       offline_pages::OfflinePageArchiver::ArchiverResult::
           ERROR_ARCHIVE_CREATION_FAILED);
   recent_tab_helper()->SetDelegate(
       std::unique_ptr<TestDelegate>(failing_delegate));
 
   NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(1U, model_changed_count());
+  EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   // the same page should be simply overridden.
   GetAllPages();
   EXPECT_EQ(0U, all_pages().size());
 }
 
 // Triggers two snapshot captures for two different page loads and URLs. Should
 // end up with one offline page.
 TEST_F(RecentTabHelperTest, TwoCapturesDifferentPageLoadsAndUrls) {
   NavigateAndCommit(kTestPageUrl);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
-  EXPECT_EQ(0U, model_changed_count());
+  EXPECT_EQ(0U, page_added_count());
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(1U, model_changed_count());
+  EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrl, all_pages()[0].url);
 
   NavigateAndCommit(kTestPageUrlOther);
   // Triggers snapshot after a time delay.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   // Move the snapshot controller's time forward so it gets past timeouts.
   FastForwardSnapshotController();
   RunUntilIdle();
-  EXPECT_EQ(2U, model_changed_count());
+  EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
   // the same page should be simply overridden.
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   EXPECT_EQ(kTestPageUrlOther, all_pages()[0].url);
 }
 
 // Simulates an error (disconnection) during the load of a page. Should end up
 // with no offline pages.
 TEST_F(RecentTabHelperTest, NoCaptureOnErrorPage) {
@@ skipping 33 matching lines @@
   GetAllPages();
   EXPECT_EQ(1U, all_pages().size());
   const OfflinePageItem& page = all_pages()[0];
   EXPECT_EQ(kTestPageUrl, page.url);
   EXPECT_EQ("download", page.client_id.name_space);
   EXPECT_EQ("id1", page.client_id.id);
   EXPECT_EQ(153l, page.offline_id);
 }
 
 }  // namespace offline_pages