[NTP::SectionOrder] Replace CategoryFactory with a category ranker.

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 <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ntp_snippets/category_info.h"
+#include "components/ntp_snippets/category_rankers/constant_category_ranker.h"
 #include "components/ntp_snippets/category_status.h"
 #include "components/ntp_snippets/content_suggestion.h"
 #include "components/ntp_snippets/content_suggestions_provider.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/testing_pref_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/image/image.h"
 
 using testing::ElementsAre;
 using testing::Eq;
 using testing::InvokeWithoutArgs;
 using testing::IsEmpty;
 using testing::Mock;
 using testing::Property;
 using testing::_;
 
 namespace ntp_snippets {
 
 namespace {
 
 class MockProvider : public ContentSuggestionsProvider {
  public:
   MockProvider(Observer* observer,
-               CategoryFactory* category_factory,
                const std::vector<Category>& provided_categories)
-      : ContentSuggestionsProvider(observer, category_factory) {
+      : ContentSuggestionsProvider(observer) {
     SetProvidedCategories(provided_categories);
   }
 
   void SetProvidedCategories(const std::vector<Category>& provided_categories) {
     statuses_.clear();
     provided_categories_ = provided_categories;
     for (Category category : provided_categories) {
       statuses_[category.id()] = CategoryStatus::AVAILABLE;
     }
   }
@@ skipping 117 matching lines @@
   const std::map<Category, ContentSuggestionsProvider*, Category::CompareByID>&
   providers() {
     return service()->providers_by_category_;
   }
 
   const std::map<Category, ContentSuggestionsProvider*, Category::CompareByID>&
   dismissed_providers() {
     return service()->dismissed_providers_by_category_;
   }
 
-  CategoryFactory* category_factory() { return service()->category_factory(); }
-
-  Category FromKnownCategory(KnownCategories known_category) {
-    return service()->category_factory()->FromKnownCategory(known_category);
-  }
-
-  Category FromRemoteCategory(int remote_category) {
-    return service()->category_factory()->FromRemoteCategory(remote_category);
-  }
-
   MockProvider* RegisterProvider(Category provided_category) {
     return RegisterProvider(std::vector<Category>({provided_category}));
   }
 
   MockProvider* RegisterProvider(
       const std::vector<Category>& provided_categories) {
-    std::unique_ptr<MockProvider> provider = base::MakeUnique<MockProvider>(
-        service(), category_factory(), provided_categories);
+    std::unique_ptr<MockProvider> provider =
+        base::MakeUnique<MockProvider>(service(), provided_categories);
     MockProvider* result = provider.get();
     service()->RegisterProvider(std::move(provider));
     return result;
   }
 
   MOCK_METHOD1(OnImageFetched, void(const gfx::Image&));
 
  protected:
   void RegisterPrefs() {
     ContentSuggestionsService::RegisterProfilePrefs(pref_service_->registry());
     UserClassifier::RegisterProfilePrefs(pref_service_->registry());
   }
 
   void CreateContentSuggestionsService(
       ContentSuggestionsService::State enabled) {
     ASSERT_FALSE(service_);
     service_.reset(new ContentSuggestionsService(
         enabled, /*signin_manager=*/nullptr, /*history_service=*/nullptr,
-        pref_service_.get()));
+        pref_service_.get(),
+        base::MakeUnique<ntp_snippets::ConstantCategoryRanker>()));
   }
 
   void ResetService() {
     service_->Shutdown();
     service_.reset();
     CreateContentSuggestionsService(ContentSuggestionsService::State::ENABLED);
   }
 
   ContentSuggestionsService* service() { return service_.get(); }
 
@@ skipping 26 matching lines @@
  public:
   void SetUp() override {
     RegisterPrefs();
     CreateContentSuggestionsService(ContentSuggestionsService::State::DISABLED);
   }
 };
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRegisterProviders) {
   EXPECT_THAT(service()->state(),
               Eq(ContentSuggestionsService::State::ENABLED));
-  Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category articles_category =
+      Category::FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
-      FromKnownCategory(KnownCategories::DOWNLOADS);
+      Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   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));
@@ skipping 15 matching lines @@
   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));
 }
 
 TEST_F(ContentSuggestionsServiceDisabledTest, ShouldDoNothingWhenDisabled) {
-  Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category articles_category =
+      Category::FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
-      FromKnownCategory(KnownCategories::DOWNLOADS);
+      Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   EXPECT_THAT(service()->state(),
               Eq(ContentSuggestionsService::State::DISABLED));
   EXPECT_THAT(providers(), IsEmpty());
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::ALL_SUGGESTIONS_EXPLICITLY_DISABLED));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::ALL_SUGGESTIONS_EXPLICITLY_DISABLED));
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
   EXPECT_THAT(service()->GetSuggestionsForCategory(articles_category),
               IsEmpty());
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectFetchSuggestionImage) {
-  Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category articles_category =
+      Category::FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
-      FromKnownCategory(KnownCategories::DOWNLOADS);
+      Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider1 = RegisterProvider(articles_category);
   MockProvider* provider2 = RegisterProvider(offline_pages_category);
 
   provider1->FireSuggestionsChanged(articles_category,
                                     CreateSuggestions(articles_category, {1}));
   ContentSuggestion::ID suggestion_id(articles_category, "1");
 
   EXPECT_CALL(*provider1, FetchSuggestionImage(suggestion_id, _));
   EXPECT_CALL(*provider2, FetchSuggestionImage(_, _)).Times(0);
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
 }
 
 TEST_F(ContentSuggestionsServiceTest,
        ShouldCallbackEmptyImageForUnavailableProvider) {
   // Setup the current thread's MessageLoop.
   base::MessageLoop message_loop;
 
   base::RunLoop run_loop;
   // Assuming there will never be a category with the id below.
-  ContentSuggestion::ID suggestion_id(category_factory()->FromIDValue(21563),
-                                      "TestID");
+  ContentSuggestion::ID suggestion_id(Category::FromIDValue(21563), "TestID");
   EXPECT_CALL(*this, OnImageFetched(Property(&gfx::Image::IsEmpty, Eq(true))))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
   run_loop.Run();
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectDismissSuggestion) {
-  Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category articles_category =
+      Category::FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
-      FromKnownCategory(KnownCategories::DOWNLOADS);
+      Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider1 = RegisterProvider(articles_category);
   MockProvider* provider2 = RegisterProvider(offline_pages_category);
 
   provider2->FireSuggestionsChanged(
       offline_pages_category, CreateSuggestions(offline_pages_category, {11}));
   ContentSuggestion::ID suggestion_id(offline_pages_category, "11");
 
   EXPECT_CALL(*provider1, DismissSuggestion(_)).Times(0);
   EXPECT_CALL(*provider2, DismissSuggestion(suggestion_id));
   service()->DismissSuggestion(suggestion_id);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectSuggestionInvalidated) {
-  Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category articles_category =
+      Category::FromKnownCategory(KnownCategories::ARTICLES);
 
   MockProvider* provider = RegisterProvider(articles_category);
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   provider->FireSuggestionsChanged(
       articles_category, CreateSuggestions(articles_category, {11, 12, 13}));
   ExpectThatSuggestionsAre(articles_category, {11, 12, 13});
 
   ContentSuggestion::ID suggestion_id(articles_category, "12");
   EXPECT_CALL(observer, OnSuggestionInvalidated(suggestion_id));
   provider->FireSuggestionInvalidated(suggestion_id);
   ExpectThatSuggestionsAre(articles_category, {11, 13});
   Mock::VerifyAndClearExpectations(&observer);
 
   // Unknown IDs must be forwarded (though no change happens to the service's
   // internal data structures) because previously opened UIs, which can still
   // show the invalidated suggestion, must be notified.
   ContentSuggestion::ID unknown_id(articles_category, "1234");
   EXPECT_CALL(observer, OnSuggestionInvalidated(unknown_id));
   provider->FireSuggestionInvalidated(unknown_id);
   ExpectThatSuggestionsAre(articles_category, {11, 13});
   Mock::VerifyAndClearExpectations(&observer);
 
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardSuggestions) {
-  Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category articles_category =
+      Category::FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
-      FromKnownCategory(KnownCategories::DOWNLOADS);
+      Category::FromKnownCategory(KnownCategories::DOWNLOADS);
 
   // 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));
@@ skipping 49 matching lines @@
 
   // Shutdown the service
   EXPECT_CALL(observer, ContentSuggestionsServiceShutdown());
   service()->Shutdown();
   service()->RemoveObserver(&observer);
   // The service will receive two Shutdown() calls.
 }
 
 TEST_F(ContentSuggestionsServiceTest,
        ShouldNotReturnCategoryInfoForNonexistentCategory) {
-  Category category = FromKnownCategory(KnownCategories::DOWNLOADS);
+  Category category = Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   base::Optional<CategoryInfo> result = service()->GetCategoryInfo(category);
   EXPECT_FALSE(result.has_value());
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldReturnCategoryInfo) {
-  Category category = FromKnownCategory(KnownCategories::DOWNLOADS);
+  Category category = Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   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_action(), Eq(actual.has_more_action()));
   EXPECT_THAT(expected.has_reload_action(), Eq(actual.has_reload_action()));
   EXPECT_THAT(expected.has_view_all_action(), Eq(actual.has_view_all_action()));
 }
 
 TEST_F(ContentSuggestionsServiceTest,
        ShouldRegisterNewCategoryOnNewSuggestions) {
-  Category category = FromKnownCategory(KnownCategories::DOWNLOADS);
+  Category category = Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   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);
+  Category new_category =
+      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,
                                    CreateSuggestions(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::DOWNLOADS);
+  Category category = Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   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);
+  Category new_category =
+      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);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRemoveCategoryWhenNotProvided) {
-  Category category = FromKnownCategory(KnownCategories::DOWNLOADS);
+  Category category = Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider = RegisterProvider(category);
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   provider->FireSuggestionsChanged(category,
                                    CreateSuggestions(category, {1, 2}));
   ExpectThatSuggestionsAre(category, {1, 2});
 
   EXPECT_CALL(observer,
               OnCategoryStatusChanged(category, CategoryStatus::NOT_PROVIDED));
   provider->FireCategoryStatusChanged(category, CategoryStatus::NOT_PROVIDED);
 
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::NOT_PROVIDED));
   EXPECT_TRUE(service()->GetCategories().empty());
   ExpectThatSuggestionsAre(category, std::vector<int>());
 
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardClearHistory) {
-  Category category = FromKnownCategory(KnownCategories::DOWNLOADS);
+  Category category = Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider = RegisterProvider(category);
   base::Time begin = base::Time::FromTimeT(123),
              end = base::Time::FromTimeT(456);
   EXPECT_CALL(*provider, ClearHistory(begin, end, _));
   base::Callback<bool(const GURL& url)> filter;
   service()->ClearHistory(begin, end, filter);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardFetch) {
-  Category category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category category = Category::FromKnownCategory(KnownCategories::ARTICLES);
   std::set<std::string> known_suggestions;
   MockProvider* provider = RegisterProvider(category);
   provider->FireCategoryStatusChangedWithCurrentStatus(category);
   EXPECT_CALL(*provider, Fetch(category, known_suggestions, _));
   service()->Fetch(category, known_suggestions, FetchDoneCallback());
 }
 
 TEST_F(ContentSuggestionsServiceTest, DismissAndRestoreCategory) {
   // Register a category with one suggestion.
-  Category category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category category = Category::FromKnownCategory(KnownCategories::ARTICLES);
   MockProvider* provider = RegisterProvider(category);
   provider->FireCategoryStatusChangedWithCurrentStatus(category);
   provider->FireSuggestionsChanged(category, CreateSuggestions(category, {42}));
 
   EXPECT_THAT(service()->GetCategories(), ElementsAre(category));
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::AVAILABLE));
   ExpectThatSuggestionsAre(category, {42});
   EXPECT_THAT(providers().count(category), Eq(1ul));
   EXPECT_THAT(dismissed_providers(), IsEmpty());
@@ skipping 15 matching lines @@
   EXPECT_THAT(service()->GetCategories(), ElementsAre(category));
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetSuggestionsForCategory(category), IsEmpty());
   EXPECT_THAT(providers().count(category), Eq(1ul));
   EXPECT_THAT(dismissed_providers(), IsEmpty());
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRestoreDismissedCategories) {
   // Create and register provider.
-  Category category1 = service()->category_factory()->FromIDValue(1);
-  Category category2 = service()->category_factory()->FromIDValue(2);
+  Category category1 = Category::FromIDValue(1);
+  Category category2 = Category::FromIDValue(2);
 
   // Setup and verify initial state.
   MockProvider* provider = RegisterProvider({category1, category2});
   provider->FireCategoryStatusChangedWithCurrentStatus(category1);
   provider->FireCategoryStatusChangedWithCurrentStatus(category2);
 
   ASSERT_THAT(service()->GetCategoryStatus(category1),
               Eq(CategoryStatus::AVAILABLE));
   ASSERT_THAT(service()->GetCategoryStatus(category2),
               Eq(CategoryStatus::AVAILABLE));
@@ skipping 28 matching lines @@
                                    CreateSuggestions(category1, {1, 2}));
 
   EXPECT_THAT(service()->GetCategoryStatus(category1),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(category2),
               Eq(CategoryStatus::NOT_PROVIDED));
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRestoreDismissalsFromPrefs) {
   // Register a category with one suggestion.
-  Category category = FromKnownCategory(KnownCategories::ARTICLES);
+  Category category = Category::FromKnownCategory(KnownCategories::ARTICLES);
   MockProvider* provider = RegisterProvider(category);
   provider->FireCategoryStatusChangedWithCurrentStatus(category);
 
   // For a regular initialisation, the category is not dismissed.
   ASSERT_FALSE(service()->IsCategoryDismissed(category));
 
   // Dismiss the category.
   service()->DismissCategory(category);
   ASSERT_TRUE(service()->IsCategoryDismissed(category));
 
   // Simulate a Chrome restart. The category should still be dismissed.
   ResetService();
   EXPECT_TRUE(service()->IsCategoryDismissed(category));
 
   // Ensure that the provider registered at initialisation is used after
   // restoration.
   provider = RegisterProvider(category);
   provider->FireCategoryStatusChangedWithCurrentStatus(category);
   EXPECT_TRUE(service()->IsCategoryDismissed(category));
 
   service()->RestoreDismissedCategories();
   EXPECT_FALSE(service()->IsCategoryDismissed(category));
   EXPECT_THAT(providers().find(category)->second, Eq(provider));
 }
 
 }  // namespace ntp_snippets