[SuggestionsService] Split SuggestionsService interface from impl

components/suggestions/suggestions_service_impl_unittest.cc

 // Copyright 2014 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/suggestions/suggestions_service.h"
+#include "components/suggestions/suggestions_service_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 103 matching lines @@
   MockSyncService() {}
   virtual ~MockSyncService() {}
   MOCK_CONST_METHOD0(CanSyncStart, bool());
   MOCK_CONST_METHOD0(IsSyncActive, bool());
   MOCK_CONST_METHOD0(ConfigurationDone, bool());
   MOCK_CONST_METHOD0(GetActiveDataTypes, syncer::ModelTypeSet());
 };
 
 class TestSuggestionsStore : public suggestions::SuggestionsStore {
  public:
-  TestSuggestionsStore() {
-    cached_suggestions = CreateSuggestionsProfile();
-  }
+  TestSuggestionsStore() { cached_suggestions = CreateSuggestionsProfile(); }
   bool LoadSuggestions(SuggestionsProfile* suggestions) override {
     suggestions->CopyFrom(cached_suggestions);
     return cached_suggestions.suggestions_size();
   }
   bool StoreSuggestions(const SuggestionsProfile& suggestions) override {
     cached_suggestions.CopyFrom(suggestions);
     return true;
   }
   void ClearSuggestions() override {
     cached_suggestions = SuggestionsProfile();
@@ skipping 64 matching lines @@
     token_service_.set_auto_post_fetch_response_on_message_loop(true);
   }
 
   ~SuggestionsServiceTest() override {}
 
   void SetUp() override {
     request_context_ =
         new net::TestURLRequestContextGetter(io_message_loop_.task_runner());
   }
 
-  SuggestionsService* CreateSuggestionsServiceWithMocks() {
+  std::unique_ptr<SuggestionsServiceImpl> CreateSuggestionsServiceWithMocks() {
     mock_sync_service_.reset(new MockSyncService);
     ON_CALL(*mock_sync_service_, CanSyncStart()).WillByDefault(Return(true));
     ON_CALL(*mock_sync_service_, IsSyncActive()).WillByDefault(Return(true));
     ON_CALL(*mock_sync_service_, ConfigurationDone())
         .WillByDefault(Return(true));
     ON_CALL(*mock_sync_service_, GetActiveDataTypes())
         .WillByDefault(
             Return(syncer::ModelTypeSet(syncer::HISTORY_DELETE_DIRECTIVES)));
 
     // These objects are owned by the returned SuggestionsService, but we keep
     // the pointer around for testing.
     test_suggestions_store_ = new TestSuggestionsStore();
     mock_thumbnail_manager_ = new StrictMock<MockImageManager>();
     mock_blacklist_store_ = new StrictMock<MockBlacklistStore>();
-    return new SuggestionsService(
+    return base::MakeUnique<SuggestionsServiceImpl>(
         nullptr /* signin_manager */, &token_service_, mock_sync_service_.get(),
         request_context_.get(), base::WrapUnique(test_suggestions_store_),
         base::WrapUnique(mock_thumbnail_manager_),
         base::WrapUnique(mock_blacklist_store_));
   }
 
   void Blacklist(SuggestionsService* suggestions_service, GURL url) {
     blacklisting_failed_ = !suggestions_service->BlacklistURL(url);
   }
 
   void UndoBlacklist(SuggestionsService* suggestions_service, GURL url) {
     undo_blacklisting_failed_ = !suggestions_service->UndoBlacklistURL(url);
   }
 
   // Helper for Undo failure tests. Depending on |is_uploaded|, tests either
   // the case where the URL is no longer in the local blacklist or the case
   // in which it's not yet candidate for upload.
   void UndoBlacklistURLFailsHelper(bool is_uploaded) {
-    std::unique_ptr<SuggestionsService> suggestions_service(
+    std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
         CreateSuggestionsServiceWithMocks());
     EXPECT_TRUE(suggestions_service != nullptr);
     // Ensure scheduling the request doesn't happen before undo.
     base::TimeDelta delay = base::TimeDelta::FromHours(1);
     suggestions_service->set_blacklist_delay(delay);
 
     auto subscription = suggestions_service->AddCallback(base::Bind(
         &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
     SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
@@ skipping 22 matching lines @@
     }
 
     Blacklist(suggestions_service.get(), blacklisted_url);
     UndoBlacklist(suggestions_service.get(), blacklisted_url);
 
     EXPECT_EQ(1, suggestions_data_callback_count_);
     EXPECT_FALSE(blacklisting_failed_);
     EXPECT_TRUE(undo_blacklisting_failed_);
   }
 
-  bool HasPendingSuggestionsRequest(SuggestionsService* suggestions_service) {
+  bool HasPendingSuggestionsRequest(
+      SuggestionsServiceImpl* suggestions_service) {
     return !!suggestions_service->pending_request_.get();
   }
 
  protected:
   base::MessageLoopForIO io_message_loop_;
   net::FakeURLFetcherFactory factory_;
   FakeProfileOAuth2TokenService token_service_;
   std::unique_ptr<MockSyncService> mock_sync_service_;
   // Only used if the SuggestionsService is built with mocks. Not owned.
   MockImageManager* mock_thumbnail_manager_;
   MockBlacklistStore* mock_blacklist_store_;
   TestSuggestionsStore* test_suggestions_store_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SuggestionsServiceTest);
 };
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsData) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
 
   // Set up net::FakeURLFetcherFactory.
-  factory_.SetFakeResponse(SuggestionsService::BuildSuggestionsURL(),
+  factory_.SetFakeResponse(SuggestionsServiceImpl::BuildSuggestionsURL(),
                            suggestions_profile.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   // Expectations.
   EXPECT_CALL(*mock_thumbnail_manager_, Initialize(_));
   EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_));
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   // Send the request. The data should be returned to the callback.
@@ skipping 29 matching lines @@
   EXPECT_EQ(0, suggestions_data_callback_count_);
 
   // |test_suggestions_store_| should still contain the default values.
   SuggestionsProfile suggestions;
   test_suggestions_store_->LoadSuggestions(&suggestions);
   EXPECT_EQ(CreateSuggestionsProfile().SerializeAsString(),
             suggestions.SerializeAsString());
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataSyncDisabled) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
   EXPECT_CALL(*mock_sync_service_, CanSyncStart())
       .WillRepeatedly(Return(false));
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   // Tell SuggestionsService that the sync state changed. The cache should be
   // cleared and empty data returned to the callback.
@@ skipping 10 matching lines @@
   // Let any network request run.
   base::RunLoop().RunUntilIdle();
 
   // Ensure that CheckCallback didn't run again.
   EXPECT_EQ(1, suggestions_data_callback_count_);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataNoAccessToken) {
   token_service_.RevokeCredentials(kAccountId);
 
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   suggestions_service->FetchSuggestionsData();
 
   // No network request should be sent.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(HasPendingSuggestionsRequest(suggestions_service.get()));
   EXPECT_EQ(0, suggestions_data_callback_count_);
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingError) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   // Fake a request error.
-  factory_.SetFakeResponse(SuggestionsService::BuildSuggestionsURL(),
+  factory_.SetFakeResponse(SuggestionsServiceImpl::BuildSuggestionsURL(),
                            "irrelevant", net::HTTP_OK,
                            net::URLRequestStatus::FAILED);
 
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->IssueRequestIfNoneOngoing(
-      SuggestionsService::BuildSuggestionsURL());
+      SuggestionsServiceImpl::BuildSuggestionsURL());
 
   // (Testing only) wait until suggestion fetch is complete.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingResponseNotOK) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   // Fake a non-200 response code.
-  factory_.SetFakeResponse(SuggestionsService::BuildSuggestionsURL(),
+  factory_.SetFakeResponse(SuggestionsServiceImpl::BuildSuggestionsURL(),
                            "irrelevant", net::HTTP_BAD_REQUEST,
                            net::URLRequestStatus::SUCCESS);
 
   // Expect that an upload to the blacklist is scheduled.
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->IssueRequestIfNoneOngoing(
-      SuggestionsService::BuildSuggestionsURL());
+      SuggestionsServiceImpl::BuildSuggestionsURL());
 
   // (Testing only) wait until suggestion fetch is complete.
   base::RunLoop().RunUntilIdle();
 
   // Expect no suggestions in the cache.
   SuggestionsProfile empty_suggestions;
   EXPECT_FALSE(test_suggestions_store_->LoadSuggestions(&empty_suggestions));
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURL) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != nullptr);
   base::TimeDelta no_delay = base::TimeDelta::FromSeconds(0);
   suggestions_service->set_blacklist_delay(no_delay);
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   GURL blacklisted_url(kBlacklistedUrl);
   GURL request_url(
-      SuggestionsService::BuildSuggestionsBlacklistURL(blacklisted_url));
+      SuggestionsServiceImpl::BuildSuggestionsBlacklistURL(blacklisted_url));
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
-  factory_.SetFakeResponse(request_url,
-                           suggestions_profile.SerializeAsString(),
+  factory_.SetFakeResponse(request_url, suggestions_profile.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*mock_thumbnail_manager_, Initialize(_)).Times(2);
 
   // Expected calls to the blacklist store.
   EXPECT_CALL(*mock_blacklist_store_, BlacklistUrl(Eq(blacklisted_url)))
       .WillOnce(Return(true));
   EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_)).Times(2);
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(DoAll(SetArgPointee<0>(no_delay), Return(true)))
       .WillOnce(Return(false));
@@ skipping 29 matching lines @@
       .WillOnce(Return(false));
 
   Blacklist(suggestions_service.get(), blacklisted_url);
 
   EXPECT_TRUE(blacklisting_failed_);
   EXPECT_EQ(0, suggestions_data_callback_count_);
 }
 
 // Initial blacklist request fails, triggering a second which succeeds.
 TEST_F(SuggestionsServiceTest, BlacklistURLRequestFails) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
   base::TimeDelta no_delay = base::TimeDelta::FromSeconds(0);
   suggestions_service->set_blacklist_delay(no_delay);
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   GURL blacklisted_url(kBlacklistedUrl);
   GURL request_url(
-      SuggestionsService::BuildSuggestionsBlacklistURL(blacklisted_url));
+      SuggestionsServiceImpl::BuildSuggestionsBlacklistURL(blacklisted_url));
   GURL blacklisted_url_alt(kBlacklistedUrlAlt);
-  GURL request_url_alt(
-      SuggestionsService::BuildSuggestionsBlacklistURL(blacklisted_url_alt));
+  GURL request_url_alt(SuggestionsServiceImpl::BuildSuggestionsBlacklistURL(
+      blacklisted_url_alt));
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
 
   // Note: we want to set the response for the blacklist URL to first
   // succeed, then fail. This doesn't seem possible. For simplicity of testing,
   // we'll pretend the URL changed in the BlacklistStore between the first and
   // the second request, and adjust expectations accordingly.
   factory_.SetFakeResponse(request_url, "irrelevant", net::HTTP_OK,
                            net::URLRequestStatus::FAILED);
   factory_.SetFakeResponse(request_url_alt,
                            suggestions_profile.SerializeAsString(),
@@ skipping 21 matching lines @@
 
   // Wait for the first scheduling, the first request, the second scheduling,
   // second request and the third scheduling. Again, note that calling
   // RunUntilIdle on the MessageLoop only works when the task is not posted for
   // the future.
   base::RunLoop().RunUntilIdle();
   CheckSuggestionsData();
 }
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURL) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
   // Ensure scheduling the request doesn't happen before undo.
   base::TimeDelta delay = base::TimeDelta::FromHours(1);
   suggestions_service->set_blacklist_delay(delay);
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
   GURL blacklisted_url(kBlacklistedUrl);
 
   // Blacklist expectations.
   EXPECT_CALL(*mock_blacklist_store_, BlacklistUrl(Eq(blacklisted_url)))
       .WillOnce(Return(true));
   EXPECT_CALL(*mock_thumbnail_manager_,
               Initialize(EqualsProto(suggestions_profile)))
       .Times(AnyNumber());
-  EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_))
-      .Times(AnyNumber());
+  EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_)).Times(AnyNumber());
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(DoAll(SetArgPointee<0>(delay), Return(true)));
   // Undo expectations.
   EXPECT_CALL(*mock_blacklist_store_,
               GetTimeUntilURLReadyForUpload(Eq(blacklisted_url), _))
       .WillOnce(DoAll(SetArgPointee<1>(delay), Return(true)));
   EXPECT_CALL(*mock_blacklist_store_, RemoveUrl(Eq(blacklisted_url)))
-    .WillOnce(Return(true));
+      .WillOnce(Return(true));
 
   Blacklist(suggestions_service.get(), blacklisted_url);
   UndoBlacklist(suggestions_service.get(), blacklisted_url);
 
   EXPECT_EQ(2, suggestions_data_callback_count_);
   EXPECT_FALSE(blacklisting_failed_);
   EXPECT_FALSE(undo_blacklisting_failed_);
 }
 
 TEST_F(SuggestionsServiceTest, ClearBlacklist) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
   // Ensure scheduling the request doesn't happen before undo.
   base::TimeDelta delay = base::TimeDelta::FromHours(1);
   suggestions_service->set_blacklist_delay(delay);
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
   GURL blacklisted_url(kBlacklistedUrl);
 
   factory_.SetFakeResponse(
-      SuggestionsService::BuildSuggestionsBlacklistClearURL(),
+      SuggestionsServiceImpl::BuildSuggestionsBlacklistClearURL(),
       suggestions_profile.SerializeAsString(), net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
   // Blacklist expectations.
   EXPECT_CALL(*mock_blacklist_store_, BlacklistUrl(Eq(blacklisted_url)))
       .WillOnce(Return(true));
   EXPECT_CALL(*mock_thumbnail_manager_,
               Initialize(EqualsProto(suggestions_profile)))
       .Times(AnyNumber());
   EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_)).Times(AnyNumber());
@@ skipping 18 matching lines @@
 
 TEST_F(SuggestionsServiceTest, GetBlacklistedUrl) {
   std::unique_ptr<GURL> request_url;
   std::unique_ptr<net::FakeURLFetcher> fetcher;
   GURL retrieved_url;
 
   // Not a blacklist request.
   request_url.reset(new GURL("http://not-blacklisting.com/a?b=c"));
   fetcher = CreateURLFetcher(*request_url, nullptr, "", net::HTTP_OK,
                              net::URLRequestStatus::SUCCESS);
-  EXPECT_FALSE(SuggestionsService::GetBlacklistedUrl(*fetcher, &retrieved_url));
+  EXPECT_FALSE(
+      SuggestionsServiceImpl::GetBlacklistedUrl(*fetcher, &retrieved_url));
 
   // An actual blacklist request.
   std::string blacklisted_url = "http://blacklisted.com/a?b=c&d=e";
   std::string encoded_blacklisted_url =
       "http%3A%2F%2Fblacklisted.com%2Fa%3Fb%3Dc%26d%3De";
   std::string blacklist_request_prefix(
-      SuggestionsService::BuildSuggestionsBlacklistURLPrefix());
+      SuggestionsServiceImpl::BuildSuggestionsBlacklistURLPrefix());
   request_url.reset(
       new GURL(blacklist_request_prefix + encoded_blacklisted_url));
   fetcher.reset();
   fetcher = CreateURLFetcher(*request_url, nullptr, "", net::HTTP_OK,
                              net::URLRequestStatus::SUCCESS);
-  EXPECT_TRUE(SuggestionsService::GetBlacklistedUrl(*fetcher, &retrieved_url));
+  EXPECT_TRUE(
+      SuggestionsServiceImpl::GetBlacklistedUrl(*fetcher, &retrieved_url));
   EXPECT_EQ(blacklisted_url, retrieved_url.spec());
 }
 
 TEST_F(SuggestionsServiceTest, UpdateBlacklistDelay) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   base::TimeDelta initial_delay = suggestions_service->blacklist_delay();
 
   // Delay unchanged on success.
   suggestions_service->UpdateBlacklistDelay(true);
   EXPECT_EQ(initial_delay, suggestions_service->blacklist_delay());
 
   // Delay increases on failure.
   suggestions_service->UpdateBlacklistDelay(false);
   EXPECT_GT(suggestions_service->blacklist_delay(), initial_delay);
 
   // Delay resets on success.
   suggestions_service->UpdateBlacklistDelay(true);
   EXPECT_EQ(initial_delay, suggestions_service->blacklist_delay());
 }
 
 TEST_F(SuggestionsServiceTest, CheckDefaultTimeStamps) {
-  std::unique_ptr<SuggestionsService> suggestions_service(
+  std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   SuggestionsProfile suggestions =
       CreateSuggestionsProfileWithExpiryTimestamps();
   suggestions_service->SetDefaultExpiryTimestamp(&suggestions,
                                                  kTestDefaultExpiry);
   EXPECT_EQ(kTestSetExpiry, suggestions.suggestions(0).expiry_ts());
   EXPECT_EQ(kTestDefaultExpiry, suggestions.suggestions(1).expiry_ts());
 }
 
 TEST_F(SuggestionsServiceTest, GetPageThumbnail) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   GURL test_url(kTestUrl);
   GURL thumbnail_url("https://www.thumbnails.com/thumb.jpg");
   base::Callback<void(const GURL&, const gfx::Image&)> dummy_callback;
 
   EXPECT_CALL(*mock_thumbnail_manager_, GetImageForURL(test_url, _));
   suggestions_service->GetPageThumbnail(test_url, dummy_callback);
 
   EXPECT_CALL(*mock_thumbnail_manager_, AddImageURL(test_url, thumbnail_url));
   EXPECT_CALL(*mock_thumbnail_manager_, GetImageForURL(test_url, _));
   suggestions_service->GetPageThumbnailWithURL(test_url, thumbnail_url,
                                                dummy_callback);
-
 }
 
 }  // namespace suggestions