[Suggestions] Moving suggestions code to a new component

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 "chrome/browser/search/suggestions/suggestions_service.h"
+#include "components/suggestions/suggestions_service.h"
 
 #include <sstream>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
-#include "chrome/browser/search/suggestions/blacklist_store.h"
-#include "chrome/browser/search/suggestions/suggestions_store.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "components/suggestions/blacklist_store.h"
+#include "components/suggestions/suggestions_store.h"
 #include "components/variations/variations_associated_data.h"
 #include "components/variations/variations_http_header_provider.h"
-#include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 using base::CancelableClosure;
-using content::BrowserThread;
 
 namespace suggestions {
 
 namespace {
 
 // Used to UMA log the state of the last response from the server.
 enum SuggestionsResponseState {
   RESPONSE_EMPTY,
   RESPONSE_INVALID,
   RESPONSE_VALID,
@@ skipping 68 matching lines @@
       << GetExperimentParam(kSuggestionsFieldTrialBlacklistUrlParam) << "=";
   return blacklist_url_prefix_stream.str();
 }
 
 }  // namespace
 
 SuggestionsService::SuggestionsService(
     net::URLRequestContextGetter* url_request_context,
     scoped_ptr<SuggestionsStore> suggestions_store,
     scoped_ptr<ImageManager> thumbnail_manager,
-    scoped_ptr<BlacklistStore> blacklist_store)
-    : suggestions_store_(suggestions_store.Pass()),
+    scoped_ptr<BlacklistStore> blacklist_store,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)

[blundell, 2014/07/24 08:31:45]

It looks like this object is created and used entirely on the UI thread...is
that right? If so, you don't even need to inject this...you could post the task
to MessageLoopProxy::Current().

+    : ui_task_runner_(ui_task_runner),
+      suggestions_store_(suggestions_store.Pass()),
       blacklist_store_(blacklist_store.Pass()),
       thumbnail_manager_(thumbnail_manager.Pass()),
       url_request_context_(url_request_context),
       blacklist_delay_sec_(kBlacklistDefaultDelaySec),
       weak_ptr_factory_(this),
       request_timeout_ms_(kDefaultRequestTimeoutMs) {
   // Obtain various parameters from Variations.
   suggestions_url_ =
       GURL(GetExperimentParam(kSuggestionsFieldTrialURLParam) + "?" +
            GetExperimentParam(kSuggestionsFieldTrialCommonParamsParam));
@@ skipping 14 matching lines @@
 }
 
 // static
 bool SuggestionsService::IsControlGroup() {
   return GetExperimentParam(kSuggestionsFieldTrialControlParam) ==
          kSuggestionsFieldTrialStateEnabled;
 }
 
 void SuggestionsService::FetchSuggestionsData(
     SuggestionsService::ResponseCallback callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   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())));
-  BrowserThread::PostDelayedTask(
-      BrowserThread::UI, FROM_HERE, pending_timeout_closure_->callback(),
+  ui_task_runner_->PostDelayedTask(
+      FROM_HERE, pending_timeout_closure_->callback(),
       base::TimeDelta::FromMilliseconds(request_timeout_ms_));
 }
 
 void SuggestionsService::FetchSuggestionsDataNoTimeout(
     SuggestionsService::ResponseCallback callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (pending_request_.get()) {
     // Request already exists, so just add requestor to queue.
     waiting_requestors_.push_back(callback);
     return;
   }
 
   // Form new request.
   DCHECK(waiting_requestors_.empty());
   waiting_requestors_.push_back(callback);
   IssueRequest(suggestions_url_);
 }
 
 void SuggestionsService::GetPageThumbnail(
     const GURL& url,
     base::Callback<void(const GURL&, const SkBitmap*)> callback) {
   thumbnail_manager_->GetImageForURL(url, callback);
 }
 
 void SuggestionsService::BlacklistURL(
     const GURL& candidate_url,
     const SuggestionsService::ResponseCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   waiting_requestors_.push_back(callback);
 
   // Blacklist locally, for immediate effect.
   if (!blacklist_store_->BlacklistUrl(candidate_url)) {
     DVLOG(1) << "Failed blacklisting attempt.";
     return;
   }
 
   // If there's an ongoing request, let it complete.
   if (pending_request_.get()) return;
-
   IssueRequest(BuildBlacklistRequestURL(blacklist_url_prefix_, candidate_url));
 }
 
 // static
 bool SuggestionsService::GetBlacklistedUrl(const net::URLFetcher& request,
                                            GURL* url) {
   bool is_blacklist_request = StartsWithASCII(request.GetOriginalURL().spec(),
                                               GetBlacklistUrlPrefix(), true);
   if (!is_blacklist_request) return false;
 
@@ skipping 30 matching lines @@
   request->SetRequestContext(url_request_context_);
   // Add Chrome experiment state to the request headers.
   net::HttpRequestHeaders headers;
   variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
       request->GetOriginalURL(), false, false, &headers);
   request->SetExtraRequestHeaders(headers.ToString());
   return request;
 }
 
 void SuggestionsService::OnRequestTimeout() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   ServeFromCache();
 }
 
 void SuggestionsService::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(pending_request_.get(), source);
-
   // We no longer need the timeout closure. Delete it whether or not it has run.
   // If it hasn't, this cancels it.
   pending_timeout_closure_.reset();
 
   // The fetcher will be deleted when the request is handled.
   scoped_ptr<const net::URLFetcher> request(pending_request_.release());
   const net::URLRequestStatus& request_status = request->GetStatus();
   if (request_status.status() != net::URLRequestStatus::SUCCESS) {
     UMA_HISTOGRAM_SPARSE_SLOWLY("Suggestions.FailedRequestErrorCode",
                                 -request_status.error());
@@ skipping 63 matching lines @@
   suggestions_store_->LoadSuggestions(&suggestions);
   FilterAndServe(&suggestions);
 }
 
 void SuggestionsService::FilterAndServe(SuggestionsProfile* suggestions) {
   blacklist_store_->FilterSuggestions(suggestions);
   DispatchRequestsAndClear(*suggestions, &waiting_requestors_);
 }
 
 void SuggestionsService::ScheduleBlacklistUpload(bool last_request_successful) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   UpdateBlacklistDelay(last_request_successful);
 
   // Schedule a blacklist upload task.
   GURL blacklist_url;
   if (blacklist_store_->GetFirstUrlFromBlacklist(&blacklist_url)) {
     base::Closure blacklist_cb =
         base::Bind(&SuggestionsService::UploadOneFromBlacklist,
                    weak_ptr_factory_.GetWeakPtr());
-    BrowserThread::PostDelayedTask(
-        BrowserThread::UI, FROM_HERE, blacklist_cb,
+    ui_task_runner_->PostDelayedTask(
+        FROM_HERE, blacklist_cb,
         base::TimeDelta::FromSeconds(blacklist_delay_sec_));
   }
 }
 
 void SuggestionsService::UploadOneFromBlacklist() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // If there's an ongoing request, let it complete.
   if (pending_request_.get()) return;
 
   GURL blacklist_url;
   if (!blacklist_store_->GetFirstUrlFromBlacklist(&blacklist_url))
     return;  // Local blacklist is empty.
 
   // Send blacklisting request.
   IssueRequest(BuildBlacklistRequestURL(blacklist_url_prefix_, blacklist_url));
 }
 
 void SuggestionsService::UpdateBlacklistDelay(bool last_request_successful) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   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