[Most Visited] Check for Sync state when using SuggestionsService.

components/suggestions/suggestions_service.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 <sstream>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 138 matching lines @@
          kSuggestionsFieldTrialStateEnabled;
 }
 
 // static
 bool SuggestionsService::IsControlGroup() {
   return GetExperimentParam(kSuggestionsFieldTrialControlParam) ==
          kSuggestionsFieldTrialStateEnabled;
 }
 
 void SuggestionsService::FetchSuggestionsData(
+    SyncState sync_state,
     SuggestionsService::ResponseCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (sync_state == NOT_INITIALIZED_ENABLED) {
+    // Sync is not initialized yet, but enabled. Serve previously cached
+    // suggestions if available.
+    waiting_requestors_.push_back(callback);
+    ServeFromCache();
+    return;
+  } else if (sync_state == DISABLED) {
+    suggestions_store_->ClearSuggestions();

[manzagop (departed), 2014/08/20 15:43:51]

Also cancel any ongoing request and serve the waiting requestors? 

Well... not sure if it's a blacklist request. Also, if we have stuff in the
blacklist store, we'll keep kicking off new requests as we get responses. So
we'll keep filling the cache.

Basically, what's the stance on stopping syncing (all / only history). Does it
apply to the content of the blacklist store, or is the user expectation that it
should be uploaded since it was blacklisted before the change?

[Mathieu, 2014/08/20 18:41:29]

We shouldn't interact with the server anymore when sync is disabled.

+    callback.Run(SuggestionsProfile());
+    return;
+  }
 
   FetchSuggestionsDataNoTimeout(callback);
 
   // Post a task to serve the cached suggestions if the request hasn't completed
   // after some time. Cancels the previous such task, if one existed.
   pending_timeout_closure_.reset(new CancelableClosure(base::Bind(
       &SuggestionsService::OnRequestTimeout, weak_ptr_factory_.GetWeakPtr())));
   base::MessageLoopProxy::current()->PostDelayedTask(
       FROM_HERE, pending_timeout_closure_->callback(),
       base::TimeDelta::FromMilliseconds(request_timeout_ms_));
@@ skipping 228 matching lines @@
   if (last_request_successful) {
     blacklist_delay_sec_ = kBlacklistDefaultDelaySec;
   } else {
     int candidate_delay = blacklist_delay_sec_ * kBlacklistBackoffMultiplier;
     if (candidate_delay < kBlacklistMaxDelaySec)
       blacklist_delay_sec_ = candidate_delay;
   }
 }
 
 }  // namespace suggestions