SuggestionsService support for Desktop

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 <string>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.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/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/suggestions/blacklist_store.h"
 #include "components/suggestions/suggestions_store.h"
 #include "components/variations/net/variations_http_header_provider.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
@@ skipping 48 matching lines @@
 // Default delay used when scheduling a request.
 const int kDefaultSchedulingDelaySec = 1;
 
 // Multiplier on the delay used when re-scheduling a failed request.
 const int kSchedulingBackoffMultiplier = 2;
 
 // Maximum valid delay for scheduling a request. Candidate delays larger than
 // this are rejected. This means the maximum backoff is at least 5 / 2 minutes.
 const int kSchedulingMaxDelaySec = 5 * 60;
 
+const char kFaviconURL[] =
+    "https://s2.googleusercontent.com/s2/favicons?domain_url=%s&alt=s&sz=32";
+
 }  // namespace
 
 // TODO(mathp): Put this in TemplateURL.
+// TODO(fserb): Add logic to decide the device type of the request.
+#if defined(OS_ANDROID) || defined(OS_IOS)
 const char kSuggestionsURL[] = "https://www.google.com/chromesuggestions?t=2";
 const char kSuggestionsBlacklistURLPrefix[] =
     "https://www.google.com/chromesuggestions/blacklist?t=2&url=";
+const char kSuggestionsBlacklistClearURL[] =
+    "https://www.google.com/chromesuggestions/blacklist/clear?t=2";
+#else
+const char kSuggestionsURL[] = "https://www.google.com/chromesuggestions?t=1";
+const char kSuggestionsBlacklistURLPrefix[] =
+    "https://www.google.com/chromesuggestions/blacklist?t=1&url=";
+const char kSuggestionsBlacklistClearURL[] =
+    "https://www.google.com/chromesuggestions/blacklist/clear?t=1";
+#endif
 const char kSuggestionsBlacklistURLParam[] = "url";
 
-// The default expiry timeout is 72 hours.
-const int64 kDefaultExpiryUsec = 72 * base::Time::kMicrosecondsPerHour;
+// The default expiry timeout is 168 hours.
+const int64 kDefaultExpiryUsec = 168 * base::Time::kMicrosecondsPerHour;
 
 SuggestionsService::SuggestionsService(
     net::URLRequestContextGetter* url_request_context,
     scoped_ptr<SuggestionsStore> suggestions_store,
     scoped_ptr<ImageManager> thumbnail_manager,
     scoped_ptr<BlacklistStore> blacklist_store)
     : url_request_context_(url_request_context),
       suggestions_store_(suggestions_store.Pass()),
       thumbnail_manager_(thumbnail_manager.Pass()),
       blacklist_store_(blacklist_store.Pass()),
@@ skipping 64 matching lines @@
       blacklist_store_->RemoveUrl(url)) {
     // The URL was not yet candidate for upload to the server and could be
     // removed from the blacklist.
     waiting_requestors_.push_back(callback);
     ServeFromCache();
     return;
   }
   fail_callback.Run();
 }
 
+void SuggestionsService::ClearBlacklist(const ResponseCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  blacklist_store_->ClearBlacklist();
+  IssueRequestIfNoneOngoing(GURL(kSuggestionsBlacklistClearURL));
+  waiting_requestors_.push_back(callback);
+  ServeFromCache();
+}
+
 // static
 bool SuggestionsService::GetBlacklistedUrl(const net::URLFetcher& request,
                                            GURL* url) {
   bool is_blacklist_request = base::StartsWith(
       request.GetOriginalURL().spec(), kSuggestionsBlacklistURLPrefix,
       base::CompareCase::SENSITIVE);
   if (!is_blacklist_request) return false;
 
   // Extract the blacklisted URL from the blacklist request.
   std::string blacklisted;
@@ skipping 101 matching lines @@
   // in the case of invalid response.
   SuggestionsProfile suggestions;
   if (suggestions_data.empty()) {
     LogResponseState(RESPONSE_EMPTY);
     suggestions_store_->ClearSuggestions();
   } else if (suggestions.ParseFromString(suggestions_data)) {
     LogResponseState(RESPONSE_VALID);
     int64 now_usec = (base::Time::NowFromSystemTime() - base::Time::UnixEpoch())
         .ToInternalValue();
     SetDefaultExpiryTimestamp(&suggestions, now_usec + kDefaultExpiryUsec);
+    PopulateFaviconUrls(&suggestions);
     suggestions_store_->StoreSuggestions(suggestions);
   } else {
     LogResponseState(RESPONSE_INVALID);
   }
 
   UpdateBlacklistDelay(true);
   ScheduleBlacklistUpload();
 }
 
+void SuggestionsService::PopulateFaviconUrls(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() {
   // Cancel pending request, then serve existing requestors from cache.
   pending_request_.reset(NULL);
   ServeFromCache();
 }
 
 void SuggestionsService::ServeFromCache() {
   SuggestionsProfile suggestions;
   // In case of empty cache or error, |suggestions| stays empty.
   suggestions_store_->LoadSuggestions(&suggestions);
@@ skipping 43 matching lines @@
     scheduling_delay_ = TimeDelta::FromSeconds(kDefaultSchedulingDelaySec);
   } else {
     TimeDelta candidate_delay =
         scheduling_delay_ * kSchedulingBackoffMultiplier;
     if (candidate_delay < TimeDelta::FromSeconds(kSchedulingMaxDelaySec))
       scheduling_delay_ = candidate_delay;
   }
 }
 
 }  // namespace suggestions