[Suggestions Service] Add support for expiring the SuggestionsStore

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 <sstream>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 83 matching lines @@
 const char kSuggestionsFieldTrialName[] = "ChromeSuggestions";
 const char kSuggestionsFieldTrialURLParam[] = "url";
 const char kSuggestionsFieldTrialCommonParamsParam[] = "common_params";
 const char kSuggestionsFieldTrialBlacklistPathParam[] = "blacklist_path";
 const char kSuggestionsFieldTrialBlacklistUrlParam[] = "blacklist_url_param";
 const char kSuggestionsFieldTrialStateParam[] = "state";
 const char kSuggestionsFieldTrialControlParam[] = "control";
 const char kSuggestionsFieldTrialStateEnabled[] = "enabled";
 const char kSuggestionsFieldTrialTimeoutMs[] = "timeout_ms";
 
+// The default expiry timeout is 72 hours.
+const int64 kDefaultExpiryUsec = 72 * base::Time::kMicrosecondsPerHour;
+
 namespace {
 
 std::string GetBlacklistUrlPrefix() {
   std::stringstream blacklist_url_prefix_stream;
   blacklist_url_prefix_stream
       << GetExperimentParam(kSuggestionsFieldTrialURLParam)
       << GetExperimentParam(kSuggestionsFieldTrialBlacklistPathParam) << "?"
       << GetExperimentParam(kSuggestionsFieldTrialCommonParamsParam) << "&"
       << GetExperimentParam(kSuggestionsFieldTrialBlacklistUrlParam) << "=";
   return blacklist_url_prefix_stream.str();
@@ skipping 183 matching lines @@
   // Handle a successful blacklisting.
   GURL blacklisted_url;
   if (GetBlacklistedUrl(*source, &blacklisted_url)) {
     blacklist_store_->RemoveUrl(blacklisted_url);
   }
 
   std::string suggestions_data;
   bool success = request->GetResponseAsString(&suggestions_data);
   DCHECK(success);
 
-  // Compute suggestions, and dispatch then to requestors. On error still
+  // Compute suggestions, and dispatch them to requestors. On error still
   // dispatch empty suggestions.
   SuggestionsProfile suggestions;
   if (suggestions_data.empty()) {
     LogResponseState(RESPONSE_EMPTY);
     suggestions_store_->ClearSuggestions();
   } else if (suggestions.ParseFromString(suggestions_data)) {
     LogResponseState(RESPONSE_VALID);
     thumbnail_manager_->Initialize(suggestions);
+
+    int64 now_usec = (base::Time::NowFromSystemTime() - base::Time::UnixEpoch())
+        .ToInternalValue();
+    SetDefaultExpiryTimestamp(&suggestions, now_usec + kDefaultExpiryUsec);
     suggestions_store_->StoreSuggestions(suggestions);
   } else {
     LogResponseState(RESPONSE_INVALID);
     suggestions_store_->LoadSuggestions(&suggestions);
   }
 
   FilterAndServe(&suggestions);
   ScheduleBlacklistUpload(true);
 }
 
+void SuggestionsService::SetDefaultExpiryTimestamp(
+    SuggestionsProfile* suggestions, int64 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::Shutdown() {
   // Cancel pending request and timeout closure, then serve existing requestors
   // from cache.
   pending_request_.reset(NULL);
   pending_timeout_closure_.reset(NULL);
   ServeFromCache();
 }
 
 void SuggestionsService::ServeFromCache() {
   SuggestionsProfile suggestions;
@@ skipping 43 matching lines @@
   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