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

components/ntp_snippets/sessions/foreign_sessions_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/sessions/foreign_sessions_suggestions_provider.h"
 
 #include <map>
 #include <utility>
 
 #include "base/callback_forward.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/ntp_snippets/category.h"
-#include "components/ntp_snippets/category_factory.h"
 #include "components/ntp_snippets/content_suggestions_provider.h"
 #include "components/ntp_snippets/mock_content_suggestions_provider_observer.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync_sessions/synced_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 85 matching lines @@
         fake_foreign_sessions_provider =
             base::MakeUnique<FakeForeignSessionsProvider>();
     fake_foreign_sessions_provider_ = fake_foreign_sessions_provider.get();
 
     // During the provider's construction the following mock calls occur.
     EXPECT_CALL(*observer(), OnNewSuggestions(_, category(), IsEmpty()));
     EXPECT_CALL(*observer(), OnCategoryStatusChanged(
                                  _, category(), CategoryStatus::AVAILABLE));
 
     provider_ = base::MakeUnique<ForeignSessionsSuggestionsProvider>(
-        &observer_, &category_factory_,
-        std::move(fake_foreign_sessions_provider), &pref_service_);
+        &observer_, std::move(fake_foreign_sessions_provider), &pref_service_);
   }
 
  protected:
   SyncedSession* GetOrCreateSession(int session_id) {
     if (sessions_map_.find(session_id) == sessions_map_.end()) {
       std::string id_as_string = base::IntToString(session_id);
       std::unique_ptr<SyncedSession> owned_session =
           base::MakeUnique<SyncedSession>();
       owned_session->session_tag = id_as_string;
       owned_session->session_name = id_as_string;
@@ skipping 18 matching lines @@
     }
     fake_foreign_sessions_provider_->SetAllForeignSessions(std::move(sessions));
   }
 
   void Dismiss(const std::string& url) {
     // The url of a given suggestion is used as the |id_within_category|.
     provider_->DismissSuggestion(ContentSuggestion::ID(category(), url));
   }
 
   Category category() {
-    return category_factory_.FromKnownCategory(KnownCategories::FOREIGN_TABS);
+    return Category::FromKnownCategory(KnownCategories::FOREIGN_TABS);
   }
 
   MockContentSuggestionsProviderObserver* observer() { return &observer_; }
 
  private:
   FakeForeignSessionsProvider* fake_foreign_sessions_provider_;
   MockContentSuggestionsProviderObserver observer_;
-  CategoryFactory category_factory_;
   TestingPrefServiceSimple pref_service_;
   std::unique_ptr<ForeignSessionsSuggestionsProvider> provider_;
   std::map<int, std::unique_ptr<SyncedSession>> sessions_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ForeignSessionsSuggestionsProviderTest);
 };
 
 TEST_F(ForeignSessionsSuggestionsProviderTest, Empty) {
   // When no sessions data is added, expect no suggestions.
   EXPECT_CALL(*observer(), OnNewSuggestions(_, category(), IsEmpty()));
@@ skipping 190 matching lines @@
   EXPECT_CALL(*observer(),
               OnNewSuggestions(
                   _, category(),
                   ElementsAre(Property(&ContentSuggestion::url, GURL(kUrl1)),
                               Property(&ContentSuggestion::url, GURL(kUrl2)))));
   AddTab(0, 0, kUrl2, TimeDelta::FromMinutes(2));
   TriggerOnChange();
 }
 
 }  // namespace ntp_snippets