SuggestionsService: don't automatically fetch on startup

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_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 254 matching lines @@
   SuggestionsProfile suggestions;
   test_suggestions_store_->LoadSuggestions(&suggestions);
   ASSERT_EQ(1, suggestions.suggestions_size());
   EXPECT_EQ(kTestTitle, suggestions.suggestions(0).title());
   EXPECT_EQ(kTestUrl, suggestions.suggestions(0).url());
   EXPECT_EQ(kTestFaviconUrl, suggestions.suggestions(0).favicon_url());
 }
 
 TEST_F(SuggestionsServiceTest, IgnoresNoopSyncChange) {
   base::MockCallback<SuggestionsService::ResponseCallback> callback;
+  EXPECT_CALL(callback, Run(_)).Times(0);
   auto subscription = suggestions_service_->AddCallback(callback.Get());
 
   factory_.SetFakeResponse(SuggestionsServiceImpl::BuildSuggestionsURL(),
                            CreateSuggestionsProfile().SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   // An no-op change should not result in a suggestions refresh.
-  EXPECT_CALL(callback, Run(_)).Times(0);
   suggestions_service_->OnStateChanged(&mock_sync_service_);
 
   // Let any network request run (there shouldn't be one).
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(SuggestionsServiceTest, IgnoresUninterestingSyncChange) {
   base::MockCallback<SuggestionsService::ResponseCallback> callback;
+  EXPECT_CALL(callback, Run(_)).Times(0);
   auto subscription = suggestions_service_->AddCallback(callback.Get());
 
   factory_.SetFakeResponse(SuggestionsServiceImpl::BuildSuggestionsURL(),
                            CreateSuggestionsProfile().SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   // An uninteresting change should not result in a network request (the
   // SyncState is INITIALIZED_ENABLED_HISTORY before and after).
   EXPECT_CALL(mock_sync_service_, GetActiveDataTypes())
       .Times(AnyNumber())
       .WillRepeatedly(Return(syncer::ModelTypeSet(
           syncer::HISTORY_DELETE_DIRECTIVES, syncer::BOOKMARKS)));
-  EXPECT_CALL(callback, Run(_)).Times(0);
   suggestions_service_->OnStateChanged(&mock_sync_service_);
 
   // Let any network request run (there shouldn't be one).
   base::RunLoop().RunUntilIdle();
 }
+
+// During startup, the state changes from NOT_INITIALIZED_ENABLED to
+// INITIALIZED_ENABLED_HISTORY (for a signed-in user with history sync enabled).
+// This should *not* result in an automatic fetch.
+TEST_F(SuggestionsServiceTest, DoesNotFetchOnStartup) {
+  // The sync service starts out inactive.
+  EXPECT_CALL(mock_sync_service_, IsSyncActive()).WillRepeatedly(Return(false));
+  suggestions_service_->OnStateChanged(&mock_sync_service_);
+
+  ASSERT_EQ(SuggestionsServiceImpl::NOT_INITIALIZED_ENABLED,
+            suggestions_service_->ComputeSyncState());
+
+  base::MockCallback<SuggestionsService::ResponseCallback> callback;
+  EXPECT_CALL(callback, Run(_)).Times(0);
+  auto subscription = suggestions_service_->AddCallback(callback.Get());
+
+  factory_.SetFakeResponse(SuggestionsServiceImpl::BuildSuggestionsURL(),
+                           CreateSuggestionsProfile().SerializeAsString(),
+                           net::HTTP_OK, net::URLRequestStatus::SUCCESS);
+
+  // Sync getting enabled should not result in a fetch.
+  EXPECT_CALL(mock_sync_service_, IsSyncActive()).WillRepeatedly(Return(true));
+  suggestions_service_->OnStateChanged(&mock_sync_service_);
+
+  ASSERT_EQ(SuggestionsServiceImpl::INITIALIZED_ENABLED_HISTORY,
+            suggestions_service_->ComputeSyncState());
+
+  // Let any network request run (there shouldn't be one).
+  base::RunLoop().RunUntilIdle();
+}
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataSyncNotInitializedEnabled) {
   EXPECT_CALL(mock_sync_service_, IsSyncActive()).WillRepeatedly(Return(false));
   suggestions_service_->OnStateChanged(&mock_sync_service_);
 
   base::MockCallback<SuggestionsService::ResponseCallback> callback;
+  EXPECT_CALL(callback, Run(_)).Times(0);
   auto subscription = suggestions_service_->AddCallback(callback.Get());
 
   // Try to fetch suggestions. Since sync is not active, no network request
   // should be sent.
-  EXPECT_CALL(callback, Run(_)).Times(0);
   suggestions_service_->FetchSuggestionsData();
 
   // Let any network request run (there shouldn't be one).
   base::RunLoop().RunUntilIdle();
 
   // |test_suggestions_store_| should still contain the default values.
   SuggestionsProfile suggestions;
   test_suggestions_store_->LoadSuggestions(&suggestions);
   EXPECT_THAT(suggestions, EqualsProto(CreateSuggestionsProfile()));
 }
@@ skipping 14 matching lines @@
   suggestions_service_->FetchSuggestionsData();
 
   // Let any network request run.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataNoAccessToken) {
   token_service_.set_auto_post_fetch_response_on_message_loop(false);
 
   base::MockCallback<SuggestionsService::ResponseCallback> callback;
+  EXPECT_CALL(callback, Run(_)).Times(0);
   auto subscription = suggestions_service_->AddCallback(callback.Get());
 
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
-  EXPECT_CALL(callback, Run(_)).Times(0);
-
   suggestions_service_->FetchSuggestionsData();
 
   token_service_.IssueErrorForAllPendingRequests(GoogleServiceAuthError(
       GoogleServiceAuthError::State::INVALID_GAIA_CREDENTIALS));
 
   // No network request should be sent.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(HasPendingSuggestionsRequest());
 }
 
@@ skipping 76 matching lines @@
   SuggestionsProfile suggestions;
   test_suggestions_store_->LoadSuggestions(&suggestions);
   ASSERT_EQ(1, suggestions.suggestions_size());
   EXPECT_EQ(kTestTitle, suggestions.suggestions(0).title());
   EXPECT_EQ(kTestUrl, suggestions.suggestions(0).url());
   EXPECT_EQ(kTestFaviconUrl, suggestions.suggestions(0).favicon_url());
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURLFails) {
   base::MockCallback<SuggestionsService::ResponseCallback> callback;
+  EXPECT_CALL(callback, Run(_)).Times(0);
   auto subscription = suggestions_service_->AddCallback(callback.Get());
 
   const GURL blacklisted_url(kBlacklistedUrl);
   EXPECT_CALL(*mock_blacklist_store_, BlacklistUrl(Eq(blacklisted_url)))
       .WillOnce(Return(false));
-  EXPECT_CALL(callback, Run(_)).Times(0);
   EXPECT_FALSE(suggestions_service_->BlacklistURL(blacklisted_url));
 }
 
 // Initial blacklist request fails, triggering a second which succeeds.
 TEST_F(SuggestionsServiceTest, BlacklistURLRequestFails) {
   const base::TimeDelta no_delay = base::TimeDelta::FromSeconds(0);
   suggestions_service_->set_blacklist_delay(no_delay);
 
   base::MockCallback<SuggestionsService::ResponseCallback> callback;
   auto subscription = suggestions_service_->AddCallback(callback.Get());
@@ skipping 231 matching lines @@
   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