Remove ContentSuggestionsProvider::GetProvidedCategories().

components/ntp_snippets/content_suggestions_service_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/content_suggestions_service.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 53 matching lines @@
   }
 
   void SetProvidedCategories(const std::vector<Category>& provided_categories) {
     statuses_.clear();
     provided_categories_ = provided_categories;
     for (Category category : provided_categories) {
       statuses_[category.id()] = CategoryStatus::AVAILABLE;
     }
   }
 
-  std::vector<Category> GetProvidedCategories() override {
-    return provided_categories_;
-  }
-
   CategoryStatus GetCategoryStatus(Category category) {
     return statuses_[category.id()];
   }
 
   CategoryInfo GetCategoryInfo(Category category) {
     return CategoryInfo(base::ASCIIToUTF16("Section title"),
                         ContentSuggestionsCardLayout::FULL_CARD, true);
   }
 
   void FireSuggestionsChanged(Category category,
                               const std::vector<int>& numbers) {
     observer()->OnNewSuggestions(this, category, CreateSuggestions(numbers));
   }
 
   void FireCategoryStatusChanged(Category category, CategoryStatus new_status) {
     statuses_[category.id()] = new_status;
     observer()->OnCategoryStatusChanged(this, category, new_status);
   }
 
+  void FireCategoryStatusChangedWithCurrentStatus(Category category) {
+    observer()->OnCategoryStatusChanged(this, category,

[Philipp Keck, 2016/08/19 14:14:13]

Couldn't this just go in the RegisterProvider method instead of being a separate
method that every test needs to call?

[vitaliii, 2016/08/19 16:14:14]

Then it is not possible to do ShouldRegisterNewCategoryOnNewSuggestions test,
which requires not to notify.

+                                        statuses_[category.id()]);
+  }
+
   void FireSuggestionInvalidated(Category category,
                                  const std::string& suggestion_id) {
     observer()->OnSuggestionInvalidated(this, category, suggestion_id);
   }
 
   MOCK_METHOD1(ClearCachedSuggestionsForDebugging, void(Category category));
   MOCK_METHOD1(GetDismissedSuggestionsForDebugging,
                std::vector<ContentSuggestion>(Category category));
   MOCK_METHOD1(ClearDismissedSuggestionsForDebugging, void(Category category));
   MOCK_METHOD1(DismissSuggestion, void(const std::string& suggestion_id));
@@ skipping 115 matching lines @@
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
   ASSERT_THAT(providers(), IsEmpty());
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::NOT_PROVIDED));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::NOT_PROVIDED));
 
   MockProvider* provider1 = RegisterProvider(articles_category);
+  provider1->FireCategoryStatusChangedWithCurrentStatus(articles_category);
   EXPECT_THAT(providers().count(offline_pages_category), Eq(0ul));
+  ASSERT_THAT(providers().count(articles_category), Eq(1ul));
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
   EXPECT_THAT(providers().size(), Eq(1ul));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(articles_category));
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::NOT_PROVIDED));
 
   MockProvider* provider2 = RegisterProvider(offline_pages_category);
+  provider2->FireCategoryStatusChangedWithCurrentStatus(offline_pages_category);
+  ASSERT_THAT(providers().count(offline_pages_category), Eq(1ul));
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
+  ASSERT_THAT(providers().count(articles_category), Eq(1ul));
   EXPECT_THAT(providers().at(offline_pages_category), Eq(provider2));
   EXPECT_THAT(providers().size(), Eq(2ul));
   EXPECT_THAT(service()->GetCategories(),
               ElementsAre(offline_pages_category, articles_category));
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::AVAILABLE));
 }
 
@@ skipping 90 matching lines @@
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardSuggestions) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
 
   // Create and register providers
   MockProvider* provider1 = RegisterProvider(articles_category);
+  provider1->FireCategoryStatusChangedWithCurrentStatus(articles_category);
   MockProvider* provider2 = RegisterProvider(offline_pages_category);
+  provider2->FireCategoryStatusChangedWithCurrentStatus(offline_pages_category);
+  ASSERT_THAT(providers().count(articles_category), Eq(1ul));
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
+  ASSERT_THAT(providers().count(offline_pages_category), Eq(1ul));
   EXPECT_THAT(providers().at(offline_pages_category), Eq(provider2));
 
   // Create and register observer
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   // Send suggestions 1 and 2
   EXPECT_CALL(observer, OnNewSuggestions(articles_category));
   provider1->FireSuggestionsChanged(articles_category, {1, 2});
   ExpectThatSuggestionsAre(articles_category, {1, 2});
@@ skipping 44 matching lines @@
 TEST_F(ContentSuggestionsServiceTest,
        ShouldNotReturnCategoryInfoForNonexistentCategory) {
   Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
   base::Optional<CategoryInfo> result = service()->GetCategoryInfo(category);
   EXPECT_FALSE(result.has_value());
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldReturnCategoryInfo) {
   Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
   MockProvider* provider = RegisterProvider(category);
+  provider->FireCategoryStatusChangedWithCurrentStatus(category);
   base::Optional<CategoryInfo> result = service()->GetCategoryInfo(category);
   ASSERT_TRUE(result.has_value());
   CategoryInfo expected = provider->GetCategoryInfo(category);
   const CategoryInfo& actual = result.value();
   EXPECT_THAT(expected.title(), Eq(actual.title()));
   EXPECT_THAT(expected.card_layout(), Eq(actual.card_layout()));
   EXPECT_THAT(expected.has_more_button(), Eq(actual.has_more_button()));
 }
 
 TEST_F(ContentSuggestionsServiceTest,
        ShouldRegisterNewCategoryOnNewSuggestions) {
   Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
   MockProvider* provider = RegisterProvider(category);
+  provider->FireCategoryStatusChangedWithCurrentStatus(category);
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   // Provider starts providing |new_category| without calling
   // |OnCategoryStatusChanged|. This is supported for now until further
   // reconsideration.
   Category new_category = FromKnownCategory(KnownCategories::ARTICLES);
   provider->SetProvidedCategories(
       std::vector<Category>({category, new_category}));
 
   EXPECT_CALL(observer, OnNewSuggestions(new_category));
   EXPECT_CALL(observer,
               OnCategoryStatusChanged(new_category, CategoryStatus::AVAILABLE));
   provider->FireSuggestionsChanged(new_category, {1, 2});
 
   ExpectThatSuggestionsAre(new_category, {1, 2});
+  ASSERT_THAT(providers().count(category), Eq(1ul));
   EXPECT_THAT(providers().at(category), Eq(provider));
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(providers().count(new_category), Eq(1ul));
   EXPECT_THAT(providers().at(new_category), Eq(provider));
   EXPECT_THAT(service()->GetCategoryStatus(new_category),
               Eq(CategoryStatus::AVAILABLE));
 
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(ContentSuggestionsServiceTest,
        ShouldRegisterNewCategoryOnCategoryStatusChanged) {
   Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
   MockProvider* provider = RegisterProvider(category);
+  provider->FireCategoryStatusChangedWithCurrentStatus(category);
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   // Provider starts providing |new_category| and calls
   // |OnCategoryStatusChanged|, but the category is not yet available.
   Category new_category = FromKnownCategory(KnownCategories::ARTICLES);
   provider->SetProvidedCategories(
       std::vector<Category>({category, new_category}));
   EXPECT_CALL(observer, OnCategoryStatusChanged(new_category,
                                                 CategoryStatus::INITIALIZING));
   provider->FireCategoryStatusChanged(new_category,
                                       CategoryStatus::INITIALIZING);
 
+  ASSERT_THAT(providers().count(new_category), Eq(1ul));
   EXPECT_THAT(providers().at(new_category), Eq(provider));
   ExpectThatSuggestionsAre(new_category, std::vector<int>());
   EXPECT_THAT(service()->GetCategoryStatus(new_category),
               Eq(CategoryStatus::INITIALIZING));
   EXPECT_THAT(service()->GetCategories(),
               Eq(std::vector<Category>({category, new_category})));
 
   service()->RemoveObserver(&observer);
 }
 
@@ skipping 12 matching lines @@
 
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::NOT_PROVIDED));
   EXPECT_TRUE(service()->GetCategories().empty());
   ExpectThatSuggestionsAre(category, std::vector<int>());
 
   service()->RemoveObserver(&observer);
 }
 
 }  // namespace ntp_snippets