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 51 matching lines @@
 // 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;
 
 }  // namespace
 
 // TODO(mathp): Put this in TemplateURL.
+// TODO(mathp): Add logic to decide the device type of the request.

[Mathieu, 2015/07/28 13:09:29]

nice one ;) mathp -> fserb 

Seriously though, can you make this a follow-up CL? I was thinking we could make
device type an argument at construction time... perhaps the
SuggestionsServiceFactory can decide which one it constructs (IFDEF could be in
there). 

I don't see IFDEF extending well here if we need to fork more than just
constants.

[fserb, 2015/07/28 15:31:33]

I mean, there's going to be an IFDEF somewhere, but sure, we can do that on the
Factory.

+#if defined(OS_ANDROID) || defined(OS_IOS) || defined(OS_CHROMEOS)

[Mathieu, 2015/07/28 13:09:29]

ChromeOS can be lumped in the desktop case.

[fserb, 2015/07/28 15:31:33]

Done.

 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);
+    PopulateFavicons(suggestions);
     suggestions_store_->StoreSuggestions(suggestions);
   } else {
     LogResponseState(RESPONSE_INVALID);
   }
 
   UpdateBlacklistDelay(true);
   ScheduleBlacklistUpload();
 }
 
+void SuggestionsService::PopulateFavicons(SuggestionsProfile* suggestions) {
+  for (int i = 0; i < suggestions.suggestions_size(); ++i) {
+    suggestions::ChromeSuggestion* s = suggestions.mutable_suggestions(i);
+    s->set_favicon_url(
+        base::StringPrintf("https://s2.googleusercontent.com/s2/"

[Mathieu, 2015/07/28 13:09:29]

bring into a constant at the top

[fserb, 2015/07/28 15:31:33]

Done.

+                           "favicons?domain_url=%s&alt=s&sz=32",
+                           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