Offline Pages: Replace Observer::OfflinePageModelChanged with OfflinePageAdded.

components/ntp_snippets/offline_pages/recent_tab_suggestions_provider_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 "components/ntp_snippets/offline_pages/recent_tab_suggestions_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 61 matching lines @@
   }
 
   Category recent_tabs_category() {
     return category_factory_.FromKnownCategory(KnownCategories::RECENT_TABS);
   }
 
   ContentSuggestion::ID GetDummySuggestionId(int id) {
     return ContentSuggestion::ID(recent_tabs_category(), base::IntToString(id));
   }
 
-  void FireOfflinePageModelChanged(const std::vector<OfflinePageItem>& items) {
-    *(model_.mutable_items()) = items;
-    provider_->OfflinePageModelChanged(&model_);
+  void AddOfflinePageToModel(const OfflinePageItem item) {
+    model_.mutable_items()->push_back(item);
+    provider_->OfflinePageAdded(&model_, item);
   }
 
   void FireOfflinePageDeleted(const OfflinePageItem& item) {
+    auto iter = std::remove(model_.mutable_items()->begin(),
+                            model_.mutable_items()->end(), item);
+    auto end = model_.mutable_items()->end();
+    model_.mutable_items()->erase(iter, end);
+
     provider_->OfflinePageDeleted(item.offline_id, item.client_id);
   }
 
   std::set<std::string> ReadDismissedIDsFromPrefs() {
     return provider_->ReadDismissedIDsFromPrefs();
   }
 
   RecentTabSuggestionsProvider* provider() { return provider_.get(); }
   FakeOfflinePageModel* model() { return &model_; }
   MockContentSuggestionsProviderObserver* observer() { return &observer_; }
   TestingPrefServiceSimple* pref_service() { return pref_service_.get(); }
 
  private:
   FakeOfflinePageModel model_;
   MockContentSuggestionsProviderObserver observer_;
   CategoryFactory category_factory_;
   std::unique_ptr<TestingPrefServiceSimple> pref_service_;
   // Last so that the dependencies are deleted after the provider.
   std::unique_ptr<RecentTabSuggestionsProvider> provider_;
 
   DISALLOW_COPY_AND_ASSIGN(RecentTabSuggestionsProviderTest);
 };
 
 TEST_F(RecentTabSuggestionsProviderTest, ShouldConvertToSuggestions) {
+  auto recent_tabs_list = CreateDummyRecentTabs({1, 2});
+  EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(2);
+  for (auto& recent_tab : recent_tabs_list)
+    AddOfflinePageToModel(recent_tab);
+
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, recent_tabs_category(),
                        UnorderedElementsAre(
                            Property(&ContentSuggestion::url,
                                     GURL("http://dummy.com/1")),
                            Property(&ContentSuggestion::url,
                                     GURL("http://dummy.com/2")),
                            Property(&ContentSuggestion::url,
                                     GURL("http://dummy.com/3")))));
-  FireOfflinePageModelChanged(CreateDummyRecentTabs({1, 2, 3}));
+  AddOfflinePageToModel(CreateDummyRecentTab(3));
 }
 
 TEST_F(RecentTabSuggestionsProviderTest, ShouldSortByMostRecentlyVisited) {
   base::Time now = base::Time::Now();
   base::Time yesterday = now - base::TimeDelta::FromDays(1);
   base::Time tomorrow = now + base::TimeDelta::FromDays(1);
-  std::vector<OfflinePageItem> offline_pages = {
-      CreateDummyRecentTab(1, now), CreateDummyRecentTab(2, yesterday),
-      CreateDummyRecentTab(3, tomorrow)};
 
   EXPECT_CALL(
       *observer(),
+      OnNewSuggestions(_, recent_tabs_category(),
+                       ElementsAre(Property(&ContentSuggestion::url,
+                                            GURL("http://dummy.com/1")))));
+  AddOfflinePageToModel(CreateDummyRecentTab(1, now));
+
+  EXPECT_CALL(
+      *observer(),
+      OnNewSuggestions(
+          _, recent_tabs_category(),
+          ElementsAre(
+              Property(&ContentSuggestion::url, GURL("http://dummy.com/1")),
+              Property(&ContentSuggestion::url, GURL("http://dummy.com/2")))));
+  AddOfflinePageToModel(CreateDummyRecentTab(2, yesterday));
+
+  EXPECT_CALL(
+      *observer(),
       OnNewSuggestions(
           _, recent_tabs_category(),
           ElementsAre(Property(&ContentSuggestion::url,
                                GURL("http://dummy.com/3")),
                       Property(&ContentSuggestion::url,
                                GURL("http://dummy.com/1")),
                       Property(&ContentSuggestion::url,
                                GURL("http://dummy.com/2")))));
-  FireOfflinePageModelChanged(offline_pages);
+  AddOfflinePageToModel(CreateDummyRecentTab(3, tomorrow));
 }
 
 TEST_F(RecentTabSuggestionsProviderTest, ShouldDeliverCorrectCategoryInfo) {
   EXPECT_FALSE(
       provider()->GetCategoryInfo(recent_tabs_category()).has_more_action());
   EXPECT_FALSE(
       provider()->GetCategoryInfo(recent_tabs_category()).has_reload_action());
   EXPECT_FALSE(provider()
                    ->GetCategoryInfo(recent_tabs_category())
                    .has_view_all_action());
 }
 
 TEST_F(RecentTabSuggestionsProviderTest, ShouldDismiss) {
-  FireOfflinePageModelChanged(CreateDummyRecentTabs({1, 2, 3, 4}));
+  EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(4);
+  auto recent_tabs_list = CreateDummyRecentTabs({1, 2, 3, 4});
+  for (auto& recent_tab : recent_tabs_list)
+    AddOfflinePageToModel(recent_tab);
 
   // Dismiss 2 and 3.
   EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(0);
   provider()->DismissSuggestion(GetDummySuggestionId(2));
   provider()->DismissSuggestion(GetDummySuggestionId(3));
   Mock::VerifyAndClearExpectations(observer());
 
   // They should disappear from the reported suggestions.
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, recent_tabs_category(),
                        UnorderedElementsAre(
                            Property(&ContentSuggestion::url,
                                     GURL("http://dummy.com/1")),
                            Property(&ContentSuggestion::url,
                                     GURL("http://dummy.com/4")))));
 
-  FireOfflinePageModelChanged(model()->items());
+  AddOfflinePageToModel(ntp_snippets::test::CreateDummyOfflinePageItem(
+      4, offline_pages::kDefaultNamespace));
   Mock::VerifyAndClearExpectations(observer());
 
   // And appear in the dismissed suggestions.
   std::vector<ContentSuggestion> dismissed_suggestions;
   provider()->GetDismissedSuggestionsForDebugging(
       recent_tabs_category(),
       base::Bind(&CaptureDismissedSuggestions, &dismissed_suggestions));
   EXPECT_THAT(
       dismissed_suggestions,
       UnorderedElementsAre(Property(&ContentSuggestion::url,
                                     GURL("http://dummy.com/2")),
                            Property(&ContentSuggestion::url,
                                     GURL("http://dummy.com/3"))));
 
   // Clear dismissed suggestions.
   provider()->ClearDismissedSuggestionsForDebugging(recent_tabs_category());
 
   // They should be gone from the dismissed suggestions.
   dismissed_suggestions.clear();
   provider()->GetDismissedSuggestionsForDebugging(
       recent_tabs_category(),
       base::Bind(&CaptureDismissedSuggestions, &dismissed_suggestions));
   EXPECT_THAT(dismissed_suggestions, IsEmpty());
 
   // And appear in the reported suggestions for the category again.
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, recent_tabs_category(), SizeIs(4)));
-  FireOfflinePageModelChanged(model()->items());
+  AddOfflinePageToModel(ntp_snippets::test::CreateDummyOfflinePageItem(
+      5, offline_pages::kDefaultNamespace));
   Mock::VerifyAndClearExpectations(observer());
 }
 
 TEST_F(RecentTabSuggestionsProviderTest,
        ShouldInvalidateWhenOfflinePageDeleted) {
+  EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(3);
   std::vector<OfflinePageItem> offline_pages = CreateDummyRecentTabs({1, 2, 3});
-  FireOfflinePageModelChanged(offline_pages);
+  for (auto& recent_tab : offline_pages)
+    AddOfflinePageToModel(recent_tab);
 
   // Invalidation of suggestion 2 should be forwarded.
   EXPECT_CALL(*observer(), OnSuggestionInvalidated(_, GetDummySuggestionId(2)));
   FireOfflinePageDeleted(offline_pages[1]);
 }
 
 TEST_F(RecentTabSuggestionsProviderTest, ShouldClearDismissedOnInvalidate) {
+  EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(3);
   std::vector<OfflinePageItem> offline_pages = CreateDummyRecentTabs({1, 2, 3});
-  FireOfflinePageModelChanged(offline_pages);
+  for (auto& recent_tab : offline_pages)
+    AddOfflinePageToModel(recent_tab);
   EXPECT_THAT(ReadDismissedIDsFromPrefs(), IsEmpty());
 
   provider()->DismissSuggestion(GetDummySuggestionId(2));
   EXPECT_THAT(ReadDismissedIDsFromPrefs(), SizeIs(1));
 
   FireOfflinePageDeleted(offline_pages[1]);
   EXPECT_THAT(ReadDismissedIDsFromPrefs(), IsEmpty());
 }
 
 TEST_F(RecentTabSuggestionsProviderTest, ShouldClearDismissedOnFetch) {
-  FireOfflinePageModelChanged(CreateDummyRecentTabs({1, 2, 3}));
+  EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(3);
+  std::vector<OfflinePageItem> offline_pages = CreateDummyRecentTabs({1, 2, 3});
+  for (auto& recent_tab : offline_pages)
+    AddOfflinePageToModel(recent_tab);
 
   provider()->DismissSuggestion(GetDummySuggestionId(2));
   provider()->DismissSuggestion(GetDummySuggestionId(3));
   EXPECT_THAT(ReadDismissedIDsFromPrefs(), SizeIs(2));
 
-  FireOfflinePageModelChanged(CreateDummyRecentTabs({2}));
+  FireOfflinePageDeleted(offline_pages[0]);
+  FireOfflinePageDeleted(offline_pages[2]);
   EXPECT_THAT(ReadDismissedIDsFromPrefs(), SizeIs(1));
 
-  FireOfflinePageModelChanged(std::vector<OfflinePageItem>());
+  FireOfflinePageDeleted(offline_pages[1]);
   EXPECT_THAT(ReadDismissedIDsFromPrefs(), IsEmpty());
 }
 
 }  // namespace ntp_snippets