[SuggestionsService] Split SuggestionsService interface from impl

components/suggestions/suggestions_service_impl.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 <memory>
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 88 matching lines @@
 GURL GetGoogleBaseURL() {
   GURL url(google_util::CommandLineGoogleBaseURL());
   if (url.is_valid())
     return url;
   return GURL(kDefaultGoogleBaseURL);
 }
 
 // Format strings for the various suggestions URLs. They all have two string
 // params: The Google base URL and the device type.
 // TODO(mathp): Put this in TemplateURL.
-const char kSuggestionsURLFormat[] =
-    "%schromesuggestions?t=%s";
+const char kSuggestionsURLFormat[] = "%schromesuggestions?t=%s";
 const char kSuggestionsBlacklistURLPrefixFormat[] =
     "%schromesuggestions/blacklist?t=%s&url=";
 const char kSuggestionsBlacklistClearURLFormat[] =
     "%schromesuggestions/blacklist/clear?t=%s";
 
 const char kSuggestionsBlacklistURLParam[] = "url";
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
 const char kDeviceType[] = "2";
 #else
 const char kDeviceType[] = "1";
 #endif
 
 // Format string for OAuth2 authentication headers.
 const char kAuthorizationHeaderFormat[] = "Authorization: Bearer %s";
 
 const char kFaviconURL[] =
     "https://s2.googleusercontent.com/s2/favicons?domain_url=%s&alt=s&sz=32";
 
 // The default expiry timeout is 168 hours.
 const int64_t kDefaultExpiryUsec = 168 * base::Time::kMicrosecondsPerHour;
 
 }  // namespace
 
 // Helper class for fetching OAuth2 access tokens.
 // To get a token, call |GetAccessToken|. Does not support multiple concurrent
 // token requests, i.e. check |HasPendingRequest| first.
-class SuggestionsService::AccessTokenFetcher
+class SuggestionsServiceImpl::AccessTokenFetcher
     : public OAuth2TokenService::Consumer {
  public:
   using TokenCallback = base::Callback<void(const std::string&)>;
 
   AccessTokenFetcher(const SigninManagerBase* signin_manager,
                      OAuth2TokenService* token_service)
       : OAuth2TokenService::Consumer("suggestions_service"),
         signin_manager_(signin_manager),
         token_service_(token_service) {}
 
   void GetAccessToken(const TokenCallback& callback) {
     callback_ = callback;
     std::string account_id;
     // |signin_manager_| can be null in unit tests.
     if (signin_manager_)
       account_id = signin_manager_->GetAuthenticatedAccountId();
     OAuth2TokenService::ScopeSet scopes;
     scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
     token_request_ = token_service_->StartRequest(account_id, scopes, this);
   }
 
-  bool HasPendingRequest() const {
-    return !!token_request_.get();
-  }
+  bool HasPendingRequest() const { return !!token_request_.get(); }
 
  private:
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const base::Time& expiration_time) override {
     DCHECK_EQ(request, token_request_.get());
     callback_.Run(access_token);
     token_request_.reset(nullptr);
   }
 
   void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                          const GoogleServiceAuthError& error) override {
     DCHECK_EQ(request, token_request_.get());
     LOG(WARNING) << "Token error: " << error.ToString();
     callback_.Run(std::string());
     token_request_.reset(nullptr);
   }
 
   const SigninManagerBase* signin_manager_;
   OAuth2TokenService* token_service_;
 
   TokenCallback callback_;
   std::unique_ptr<OAuth2TokenService::Request> token_request_;
 };
 
-SuggestionsService::SuggestionsService(
+SuggestionsServiceImpl::SuggestionsServiceImpl(
     const SigninManagerBase* signin_manager,
     OAuth2TokenService* token_service,
     syncer::SyncService* sync_service,
     net::URLRequestContextGetter* url_request_context,
     std::unique_ptr<SuggestionsStore> suggestions_store,
     std::unique_ptr<ImageManager> thumbnail_manager,
     std::unique_ptr<BlacklistStore> blacklist_store)
     : sync_service_(sync_service),
       sync_service_observer_(this),
       url_request_context_(url_request_context),
       suggestions_store_(std::move(suggestions_store)),
       thumbnail_manager_(std::move(thumbnail_manager)),
       blacklist_store_(std::move(blacklist_store)),
       scheduling_delay_(TimeDelta::FromSeconds(kDefaultSchedulingDelaySec)),
       token_fetcher_(new AccessTokenFetcher(signin_manager, token_service)),
       weak_ptr_factory_(this) {
   // |sync_service_| is null if switches::kDisableSync is set (tests use that).
   if (sync_service_)
     sync_service_observer_.Add(sync_service_);
   // Immediately get the current sync state, so we'll flush the cache if
   // necessary.
   OnStateChanged();
 }
 
-SuggestionsService::~SuggestionsService() {}
+SuggestionsServiceImpl::~SuggestionsServiceImpl() {}
 
-bool SuggestionsService::FetchSuggestionsData() {
+bool SuggestionsServiceImpl::FetchSuggestionsData() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // If sync state allows, issue a network request to refresh the suggestions.
   if (GetSyncState(sync_service_) != INITIALIZED_ENABLED_HISTORY)
     return false;
   IssueRequestIfNoneOngoing(BuildSuggestionsURL());
   return true;
 }
 
-SuggestionsProfile SuggestionsService::GetSuggestionsDataFromCache() const {
+base::Optional<SuggestionsProfile>
+SuggestionsServiceImpl::GetSuggestionsDataFromCache() const {
   SuggestionsProfile suggestions;
-  // In case of empty cache or error, |suggestions| stays empty.
-  suggestions_store_->LoadSuggestions(&suggestions);
+  // In case of empty cache or error, return empty.
+  if (!suggestions_store_->LoadSuggestions(&suggestions)) {
+    return base::Optional<SuggestionsProfile>();
+  }
   thumbnail_manager_->Initialize(suggestions);
   blacklist_store_->FilterSuggestions(&suggestions);
-  return suggestions;
+  return base::Optional<SuggestionsProfile>(suggestions);
 }
 
-std::unique_ptr<SuggestionsService::ResponseCallbackList::Subscription>
-SuggestionsService::AddCallback(const ResponseCallback& callback) {
+std::unique_ptr<SuggestionsServiceImpl::ResponseCallbackList::Subscription>
+SuggestionsServiceImpl::AddCallback(const ResponseCallback& callback) {
   return callback_list_.Add(callback);
 }
 
-void SuggestionsService::GetPageThumbnail(const GURL& url,
-                                          const BitmapCallback& callback) {
+void SuggestionsServiceImpl::GetPageThumbnail(const GURL& url,
+                                              const BitmapCallback& callback) {
   thumbnail_manager_->GetImageForURL(url, callback);
 }
 
-void SuggestionsService::GetPageThumbnailWithURL(
+void SuggestionsServiceImpl::GetPageThumbnailWithURL(
     const GURL& url,
     const GURL& thumbnail_url,
     const BitmapCallback& callback) {
   thumbnail_manager_->AddImageURL(url, thumbnail_url);
   GetPageThumbnail(url, callback);
 }
 
-bool SuggestionsService::BlacklistURL(const GURL& candidate_url) {
+bool SuggestionsServiceImpl::BlacklistURL(const GURL& candidate_url) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!blacklist_store_->BlacklistUrl(candidate_url))
     return false;
 
-  callback_list_.Notify(GetSuggestionsDataFromCache());
+  callback_list_.Notify(
+      GetSuggestionsDataFromCache().value_or(SuggestionsProfile()));
 
   // Blacklist uploads are scheduled on any request completion, so only schedule
   // an upload if there is no ongoing request.
   if (!pending_request_.get())
     ScheduleBlacklistUpload();
 
   return true;
 }
 
-bool SuggestionsService::UndoBlacklistURL(const GURL& url) {
+bool SuggestionsServiceImpl::UndoBlacklistURL(const GURL& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TimeDelta time_delta;
   if (blacklist_store_->GetTimeUntilURLReadyForUpload(url, &time_delta) &&
       time_delta > TimeDelta::FromSeconds(0) &&
       blacklist_store_->RemoveUrl(url)) {
     // The URL was not yet candidate for upload to the server and could be
     // removed from the blacklist.
-    callback_list_.Notify(GetSuggestionsDataFromCache());
+    callback_list_.Notify(
+        GetSuggestionsDataFromCache().value_or(SuggestionsProfile()));
     return true;
   }
   return false;
 }
 
-void SuggestionsService::ClearBlacklist() {
+void SuggestionsServiceImpl::ClearBlacklist() {
   DCHECK(thread_checker_.CalledOnValidThread());
   blacklist_store_->ClearBlacklist();
-  callback_list_.Notify(GetSuggestionsDataFromCache());
+  callback_list_.Notify(
+      GetSuggestionsDataFromCache().value_or(SuggestionsProfile()));
   IssueRequestIfNoneOngoing(BuildSuggestionsBlacklistClearURL());
 }
 
 // static
-bool SuggestionsService::GetBlacklistedUrl(const net::URLFetcher& request,
-                                           GURL* url) {
+bool SuggestionsServiceImpl::GetBlacklistedUrl(const net::URLFetcher& request,
+                                               GURL* url) {
   bool is_blacklist_request = base::StartsWith(
       request.GetOriginalURL().spec(), BuildSuggestionsBlacklistURLPrefix(),
       base::CompareCase::SENSITIVE);
-  if (!is_blacklist_request) return false;
+  if (!is_blacklist_request)
+    return false;
 
   // Extract the blacklisted URL from the blacklist request.
   std::string blacklisted;
-  if (!net::GetValueForKeyInQuery(
-          request.GetOriginalURL(),
-          kSuggestionsBlacklistURLParam,
-          &blacklisted)) {
+  if (!net::GetValueForKeyInQuery(request.GetOriginalURL(),
+                                  kSuggestionsBlacklistURLParam,
+                                  &blacklisted)) {
     return false;
   }
 
   GURL blacklisted_url(blacklisted);
   blacklisted_url.Swap(url);
   return true;
 }
 
 // static
-void SuggestionsService::RegisterProfilePrefs(
+void SuggestionsServiceImpl::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   SuggestionsStore::RegisterProfilePrefs(registry);
   BlacklistStore::RegisterProfilePrefs(registry);
 }
 
 // static
-GURL SuggestionsService::BuildSuggestionsURL() {
-  return GURL(base::StringPrintf(kSuggestionsURLFormat,
-                                 GetGoogleBaseURL().spec().c_str(),
-                                 kDeviceType));
+GURL SuggestionsServiceImpl::BuildSuggestionsURL() {
+  return GURL(base::StringPrintf(
+      kSuggestionsURLFormat, GetGoogleBaseURL().spec().c_str(), kDeviceType));
 }
 
 // static
-std::string SuggestionsService::BuildSuggestionsBlacklistURLPrefix() {
+std::string SuggestionsServiceImpl::BuildSuggestionsBlacklistURLPrefix() {
   return base::StringPrintf(kSuggestionsBlacklistURLPrefixFormat,
                             GetGoogleBaseURL().spec().c_str(), kDeviceType);
 }
 
 // static
-GURL SuggestionsService::BuildSuggestionsBlacklistURL(
+GURL SuggestionsServiceImpl::BuildSuggestionsBlacklistURL(
     const GURL& candidate_url) {
   return GURL(BuildSuggestionsBlacklistURLPrefix() +
               net::EscapeQueryParamValue(candidate_url.spec(), true));
 }
 
 // static
-GURL SuggestionsService::BuildSuggestionsBlacklistClearURL() {
+GURL SuggestionsServiceImpl::BuildSuggestionsBlacklistClearURL() {
   return GURL(base::StringPrintf(kSuggestionsBlacklistClearURLFormat,
                                  GetGoogleBaseURL().spec().c_str(),
                                  kDeviceType));
 }
 
-void SuggestionsService::OnStateChanged() {
+void SuggestionsServiceImpl::OnStateChanged() {
   switch (GetSyncState(sync_service_)) {
     case SYNC_OR_HISTORY_SYNC_DISABLED:
       // Cancel any ongoing request, to stop interacting with the server.
       pending_request_.reset(nullptr);
       suggestions_store_->ClearSuggestions();
       callback_list_.Notify(SuggestionsProfile());
       break;
     case NOT_INITIALIZED_ENABLED:
       // Keep the cache (if any), but don't refresh.
       break;
     case INITIALIZED_ENABLED_HISTORY:
       // If we have any observers, issue a network request to refresh the
       // suggestions in the cache.
       if (!callback_list_.empty())
         IssueRequestIfNoneOngoing(BuildSuggestionsURL());
       break;
   }
 }
 
-void SuggestionsService::SetDefaultExpiryTimestamp(
+void SuggestionsServiceImpl::SetDefaultExpiryTimestamp(
     SuggestionsProfile* suggestions,
     int64_t default_timestamp_usec) {
   for (int i = 0; i < suggestions->suggestions_size(); ++i) {
     ChromeSuggestion* suggestion = suggestions->mutable_suggestions(i);
     // Do not set expiry if the server has already provided a more specific
     // expiry time for this suggestion.
     if (!suggestion->has_expiry_ts()) {
       suggestion->set_expiry_ts(default_timestamp_usec);
     }
   }
 }
 
-void SuggestionsService::IssueRequestIfNoneOngoing(const GURL& url) {
+void SuggestionsServiceImpl::IssueRequestIfNoneOngoing(const GURL& url) {
   // If there is an ongoing request, let it complete.
   if (pending_request_.get()) {
     return;
   }
   // If there is an ongoing token request, also wait for that.
   if (token_fetcher_->HasPendingRequest()) {
     return;
   }
   token_fetcher_->GetAccessToken(
-      base::Bind(&SuggestionsService::IssueSuggestionsRequest,
+      base::Bind(&SuggestionsServiceImpl::IssueSuggestionsRequest,
                  base::Unretained(this), url));
 }
 
-void SuggestionsService::IssueSuggestionsRequest(
+void SuggestionsServiceImpl::IssueSuggestionsRequest(
     const GURL& url,
     const std::string& access_token) {
   if (access_token.empty()) {
     UpdateBlacklistDelay(false);
     ScheduleBlacklistUpload();
     return;
   }
   pending_request_ = CreateSuggestionsRequest(url, access_token);
   pending_request_->Start();
   last_request_started_time_ = TimeTicks::Now();
 }
 
-std::unique_ptr<net::URLFetcher> SuggestionsService::CreateSuggestionsRequest(
+std::unique_ptr<net::URLFetcher>
+SuggestionsServiceImpl::CreateSuggestionsRequest(
     const GURL& url,
     const std::string& access_token) {
   std::unique_ptr<net::URLFetcher> request =
       net::URLFetcher::Create(0, url, net::URLFetcher::GET, this);
   data_use_measurement::DataUseUserData::AttachToFetcher(
       request.get(), data_use_measurement::DataUseUserData::SUGGESTIONS);
   int load_flags = net::LOAD_DISABLE_CACHE | net::LOAD_DO_NOT_SEND_COOKIES |
                    net::LOAD_DO_NOT_SAVE_COOKIES;
 
   request->SetLoadFlags(load_flags);
   request->SetRequestContext(url_request_context_);
   // Add Chrome experiment state to the request headers.
   net::HttpRequestHeaders headers;
   variations::AppendVariationHeaders(request->GetOriginalURL(), false, false,
                                      &headers);
   request->SetExtraRequestHeaders(headers.ToString());
   if (!access_token.empty()) {
     request->AddExtraRequestHeader(
         base::StringPrintf(kAuthorizationHeaderFormat, access_token.c_str()));
   }
   return request;
 }
 
-void SuggestionsService::OnURLFetchComplete(const net::URLFetcher* source) {
+void SuggestionsServiceImpl::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(pending_request_.get(), source);
 
   // The fetcher will be deleted when the request is handled.
   std::unique_ptr<const net::URLFetcher> request(std::move(pending_request_));
 
   const net::URLRequestStatus& request_status = request->GetStatus();
   if (request_status.status() != net::URLRequestStatus::SUCCESS) {
     // This represents network errors (i.e. the server did not provide a
     // response).
@@ skipping 42 matching lines @@
     int64_t now_usec =
         (base::Time::NowFromSystemTime() - base::Time::UnixEpoch())
             .ToInternalValue();
     SetDefaultExpiryTimestamp(&suggestions, now_usec + kDefaultExpiryUsec);
     PopulateExtraData(&suggestions);
     suggestions_store_->StoreSuggestions(suggestions);
   } else {
     LogResponseState(RESPONSE_INVALID);
   }
 
-  callback_list_.Notify(GetSuggestionsDataFromCache());
+  callback_list_.Notify(
+      GetSuggestionsDataFromCache().value_or(SuggestionsProfile()));
 
   UpdateBlacklistDelay(true);
   ScheduleBlacklistUpload();
 }
 
-void SuggestionsService::PopulateExtraData(SuggestionsProfile* suggestions) {
+void SuggestionsServiceImpl::PopulateExtraData(
+    SuggestionsProfile* suggestions) {
   for (int i = 0; i < suggestions->suggestions_size(); ++i) {
     suggestions::ChromeSuggestion* s = suggestions->mutable_suggestions(i);
     if (!s->has_favicon_url() || s->favicon_url().empty()) {
       s->set_favicon_url(base::StringPrintf(kFaviconURL, s->url().c_str()));
     }
   }
 }
 
-void SuggestionsService::Shutdown() {
+void SuggestionsServiceImpl::Shutdown() {
   // Cancel pending request.
   pending_request_.reset(nullptr);
 }
 
-void SuggestionsService::ScheduleBlacklistUpload() {
+void SuggestionsServiceImpl::ScheduleBlacklistUpload() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TimeDelta time_delta;
   if (blacklist_store_->GetTimeUntilReadyForUpload(&time_delta)) {
     // Blacklist cache is not empty: schedule.
     base::Closure blacklist_cb =
-        base::Bind(&SuggestionsService::UploadOneFromBlacklist,
+        base::Bind(&SuggestionsServiceImpl::UploadOneFromBlacklist,
                    weak_ptr_factory_.GetWeakPtr());
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, blacklist_cb, time_delta + scheduling_delay_);
   }
 }
 
-void SuggestionsService::UploadOneFromBlacklist() {
+void SuggestionsServiceImpl::UploadOneFromBlacklist() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   GURL blacklisted_url;
   if (blacklist_store_->GetCandidateForUpload(&blacklisted_url)) {
     // Issue a blacklisting request. Even if this request ends up not being sent
     // because of an ongoing request, a blacklist request is later scheduled.
     IssueRequestIfNoneOngoing(BuildSuggestionsBlacklistURL(blacklisted_url));
     return;
   }
 
   // Even though there's no candidate for upload, the blacklist might not be
   // empty.
   ScheduleBlacklistUpload();
 }
 
-void SuggestionsService::UpdateBlacklistDelay(bool last_request_successful) {
+void SuggestionsServiceImpl::UpdateBlacklistDelay(
+    bool last_request_successful) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (last_request_successful) {
     scheduling_delay_ = TimeDelta::FromSeconds(kDefaultSchedulingDelaySec);
   } else {
     TimeDelta candidate_delay =
         scheduling_delay_ * kSchedulingBackoffMultiplier;
     if (candidate_delay < TimeDelta::FromSeconds(kSchedulingMaxDelaySec))
       scheduling_delay_ = candidate_delay;
   }
 }
 
 }  // namespace suggestions