1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/search/suggestions/suggestions_service.h" 6 7 #include "base/memory/scoped_ptr.h" 8 #include "base/metrics/field_trial.h" 9 #include "base/metrics/histogram.h" 10 #include "base/metrics/sparse_histogram.h" 11 #include "base/strings/string_number_conversions.h" 12 #include "base/strings/string_util.h" 13 #include "base/time/time.h" 14 #include "chrome/browser/browser_process.h" 15 #include "chrome/browser/history/history_types.h" 16 #include "chrome/browser/metrics/variations/variations_http_header_provider.h" 17 #include "chrome/browser/profiles/profile.h" 18 #include "chrome/browser/search/suggestions/suggestions_store.h" 19 #include "components/pref_registry/pref_registry_syncable.h" 20 #include "components/variations/variations_associated_data.h" 21 #include "content/public/browser/browser_thread.h" 22 #include "net/base/escape.h" 23 #include "net/base/load_flags.h" 24 #include "net/base/net_errors.h" 25 #include "net/http/http_response_headers.h" 26 #include "net/http/http_status_code.h" 27 #include "net/http/http_util.h" 28 #include "net/url_request/url_fetcher.h" 29 #include "net/url_request/url_request_status.h" 30 #include "url/gurl.h" 31 32 using base::CancelableClosure; 33 using content::BrowserThread; 34 35 namespace suggestions { 36 37 namespace { 38 39 // Used to UMA log the state of the last response from the server. 40 enum SuggestionsResponseState { 41 RESPONSE_EMPTY, 42 RESPONSE_INVALID, 43 RESPONSE_VALID, 44 RESPONSE_STATE_SIZE 45 }; 46 47 // Will log the supplied response |state|. 48 void LogResponseState(SuggestionsResponseState state) { 49 UMA_HISTOGRAM_ENUMERATION("Suggestions.ResponseState", state, 50 RESPONSE_STATE_SIZE); 51 } 52 53 // Obtains the experiment parameter under the supplied |key|, or empty string 54 // if the parameter does not exist. 55 std::string GetExperimentParam(const std::string& key) { 56 return chrome_variations::GetVariationParamValue(kSuggestionsFieldTrialName, 57 key); 58 } 59 60 // Runs each callback in |requestors| on |suggestions|, then deallocates 61 // |requestors|. 62 void DispatchRequestsAndClear( 63 const SuggestionsProfile& suggestions, 64 std::vector<SuggestionsService::ResponseCallback>* requestors) { 65 std::vector<SuggestionsService::ResponseCallback>::iterator it; 66 for (it = requestors->begin(); it != requestors->end(); ++it) { 67 it->Run(suggestions); 68 } 69 std::vector<SuggestionsService::ResponseCallback>().swap(*requestors); 70 } 71 72 const int kDefaultRequestTimeoutMs = 200; 73 74 } // namespace 75 76 const char kSuggestionsFieldTrialName[] = "ChromeSuggestions"; 77 const char kSuggestionsFieldTrialURLParam[] = "url"; 78 const char kSuggestionsFieldTrialSuggestionsSuffixParam[] = 79 "suggestions_suffix"; 80 const char kSuggestionsFieldTrialBlacklistSuffixParam[] = "blacklist_suffix"; 81 const char kSuggestionsFieldTrialStateParam[] = "state"; 82 const char kSuggestionsFieldTrialControlParam[] = "control"; 83 const char kSuggestionsFieldTrialStateEnabled[] = "enabled"; 84 const char kSuggestionsFieldTrialTimeoutMs[] = "timeout_ms"; 85 86 SuggestionsService::SuggestionsService( 87 Profile* profile, scoped_ptr<SuggestionsStore> suggestions_store) 88 : suggestions_store_(suggestions_store.Pass()), 89 thumbnail_manager_(new ThumbnailManager(profile)), 90 profile_(profile), 91 weak_ptr_factory_(this), 92 request_timeout_ms_(kDefaultRequestTimeoutMs) { 93 // Obtain various parameters from Variations. 94 suggestions_url_ = 95 GURL(GetExperimentParam(kSuggestionsFieldTrialURLParam) + 96 GetExperimentParam(kSuggestionsFieldTrialSuggestionsSuffixParam)); 97 blacklist_url_prefix_ = 98 GetExperimentParam(kSuggestionsFieldTrialURLParam) + 99 GetExperimentParam(kSuggestionsFieldTrialBlacklistSuffixParam); 100 std::string timeout = GetExperimentParam(kSuggestionsFieldTrialTimeoutMs); 101 int temp_timeout; 102 if (!timeout.empty() && base::StringToInt(timeout, &temp_timeout)) { 103 request_timeout_ms_ = temp_timeout; 104 } 105 } 106 107 SuggestionsService::~SuggestionsService() {} 108 109 // static 110 bool SuggestionsService::IsEnabled() { 111 return GetExperimentParam(kSuggestionsFieldTrialStateParam) == 112 kSuggestionsFieldTrialStateEnabled; 113 } 114 115 // static 116 bool SuggestionsService::IsControlGroup() { 117 return GetExperimentParam(kSuggestionsFieldTrialControlParam) == 118 kSuggestionsFieldTrialStateEnabled; 119 } 120 121 void SuggestionsService::FetchSuggestionsData( 122 SuggestionsService::ResponseCallback callback) { 123 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 124 125 FetchSuggestionsDataNoTimeout(callback); 126 127 // Post a task to serve the cached suggestions if the request hasn't completed 128 // after some time. Cancels the previous such task, if one existed. 129 pending_timeout_closure_.reset(new CancelableClosure(base::Bind( 130 &SuggestionsService::OnRequestTimeout, weak_ptr_factory_.GetWeakPtr()))); 131 BrowserThread::PostDelayedTask( 132 BrowserThread::UI, FROM_HERE, pending_timeout_closure_->callback(), 133 base::TimeDelta::FromMilliseconds(request_timeout_ms_)); 134 } 135 136 void SuggestionsService::FetchSuggestionsDataNoTimeout( 137 SuggestionsService::ResponseCallback callback) { 138 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 139 if (pending_request_.get()) { 140 // Request already exists, so just add requestor to queue. 141 waiting_requestors_.push_back(callback); 142 return; 143 } 144 145 // Form new request. 146 DCHECK(waiting_requestors_.empty()); 147 waiting_requestors_.push_back(callback); 148 149 pending_request_.reset(CreateSuggestionsRequest(suggestions_url_)); 150 pending_request_->Start(); 151 last_request_started_time_ = base::TimeTicks::Now(); 152 } 153 154 void SuggestionsService::GetPageThumbnail( 155 const GURL& url, 156 base::Callback<void(const GURL&, const SkBitmap*)> callback) { 157 thumbnail_manager_->GetPageThumbnail(url, callback); 158 } 159 160 void SuggestionsService::BlacklistURL( 161 const GURL& candidate_url, SuggestionsService::ResponseCallback callback) { 162 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 163 waiting_requestors_.push_back(callback); 164 165 if (pending_request_.get()) { 166 if (IsBlacklistRequest(pending_request_.get())) { 167 // Pending request is a blacklist request. Silently drop the new blacklist 168 // request. TODO - handle this case. 169 return; 170 } else { 171 // Pending request is not a blacklist request - cancel it and go on to 172 // issuing a blacklist request. Also ensure the timeout closure does not 173 // run; instead we'll wait for the updated suggestions before servicing 174 // requestors. 175 pending_request_.reset(NULL); 176 pending_timeout_closure_.reset(NULL); 177 } 178 } 179 180 // Send blacklisting request. 181 // TODO(manzagop): make this a PUT request instead of a GET request. 182 GURL url(blacklist_url_prefix_ + 183 net::EscapeQueryParamValue(candidate_url.spec(), true)); 184 pending_request_.reset(CreateSuggestionsRequest(url)); 185 pending_request_->Start(); 186 last_request_started_time_ = base::TimeTicks::Now(); 187 } 188 189 // static 190 void SuggestionsService::RegisterProfilePrefs( 191 user_prefs::PrefRegistrySyncable* registry) { 192 SuggestionsStore::RegisterProfilePrefs(registry); 193 } 194 195 void SuggestionsService::OnRequestTimeout() { 196 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 197 ServeFromCache(); 198 } 199 200 void SuggestionsService::OnURLFetchComplete(const net::URLFetcher* source) { 201 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 202 DCHECK_EQ(pending_request_.get(), source); 203 204 // We no longer need the timeout closure. Delete it whether or not it has run 205 // (if it hasn't, this cancels it). 206 pending_timeout_closure_.reset(); 207 208 // The fetcher will be deleted when the request is handled. 209 scoped_ptr<const net::URLFetcher> request(pending_request_.release()); 210 const net::URLRequestStatus& request_status = request->GetStatus(); 211 if (request_status.status() != net::URLRequestStatus::SUCCESS) { 212 UMA_HISTOGRAM_SPARSE_SLOWLY("Suggestions.FailedRequestErrorCode", 213 -request_status.error()); 214 DVLOG(1) << "Suggestions server request failed with error: " 215 << request_status.error() << ": " 216 << net::ErrorToString(request_status.error()); 217 // Dispatch the cached profile on error. 218 ServeFromCache(); 219 return; 220 } 221 222 // Log the response code. 223 const int response_code = request->GetResponseCode(); 224 UMA_HISTOGRAM_SPARSE_SLOWLY("Suggestions.FetchResponseCode", response_code); 225 if (response_code != net::HTTP_OK) { 226 // Aggressively clear the store. 227 suggestions_store_->ClearSuggestions(); 228 DispatchRequestsAndClear(SuggestionsProfile(), &waiting_requestors_); 229 return; 230 } 231 232 const base::TimeDelta latency = 233 base::TimeTicks::Now() - last_request_started_time_; 234 UMA_HISTOGRAM_MEDIUM_TIMES("Suggestions.FetchSuccessLatency", latency); 235 236 std::string suggestions_data; 237 bool success = request->GetResponseAsString(&suggestions_data); 238 DCHECK(success); 239 240 // Compute suggestions, and dispatch then to requestors. On error still 241 // dispatch empty suggestions. 242 SuggestionsProfile suggestions; 243 if (suggestions_data.empty()) { 244 LogResponseState(RESPONSE_EMPTY); 245 suggestions_store_->ClearSuggestions(); 246 } else if (suggestions.ParseFromString(suggestions_data)) { 247 LogResponseState(RESPONSE_VALID); 248 thumbnail_manager_->InitializeThumbnailMap(suggestions); 249 suggestions_store_->StoreSuggestions(suggestions); 250 } else { 251 LogResponseState(RESPONSE_INVALID); 252 suggestions_store_->LoadSuggestions(&suggestions); 253 } 254 255 DispatchRequestsAndClear(suggestions, &waiting_requestors_); 256 } 257 258 void SuggestionsService::Shutdown() { 259 // Cancel pending request and timeout closure, then serve existing requestors 260 // from cache. 261 pending_request_.reset(NULL); 262 pending_timeout_closure_.reset(NULL); 263 ServeFromCache(); 264 } 265 266 bool SuggestionsService::IsBlacklistRequest(net::URLFetcher* request) const { 267 DCHECK(request); 268 return StartsWithASCII(request->GetOriginalURL().spec(), 269 blacklist_url_prefix_, true); 270 } 271 272 net::URLFetcher* SuggestionsService::CreateSuggestionsRequest(const GURL& url) { 273 net::URLFetcher* request = 274 net::URLFetcher::Create(0, url, net::URLFetcher::GET, this); 275 request->SetLoadFlags(net::LOAD_DISABLE_CACHE); 276 request->SetRequestContext(profile_->GetRequestContext()); 277 // Add Chrome experiment state to the request headers. 278 net::HttpRequestHeaders headers; 279 chrome_variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders( 280 request->GetOriginalURL(), profile_->IsOffTheRecord(), false, &headers); 281 request->SetExtraRequestHeaders(headers.ToString()); 282 return request; 283 } 284 285 void SuggestionsService::ServeFromCache() { 286 SuggestionsProfile suggestions; 287 suggestions_store_->LoadSuggestions(&suggestions); 288 DispatchRequestsAndClear(suggestions, &waiting_requestors_); 289 } 290 291 } // namespace suggestions 292
