SuggestionsService undo blacklist functionality.

components/suggestions/blacklist_store.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/blacklist_store.h"
 
+#include <algorithm>
 #include <set>
 #include <string>
 
 #include "base/base64.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/suggestions/suggestions_pref_names.h"
 
+using base::TimeDelta;
+using base::TimeTicks;
+
 namespace suggestions {
-
 namespace {
 
 void PopulateBlacklistSet(const SuggestionsBlacklist& blacklist_proto,
                           std::set<std::string>* blacklist_set) {
   blacklist_set->clear();
   for (int i = 0; i < blacklist_proto.urls_size(); ++i) {
     blacklist_set->insert(blacklist_proto.urls(i));
   }
 }
 
 void PopulateBlacklistProto(const std::set<std::string>& blacklist_set,
                             SuggestionsBlacklist* blacklist_proto) {
   blacklist_proto->Clear();
   for (std::set<std::string>::const_iterator it = blacklist_set.begin();
        it != blacklist_set.end(); ++it) {
     blacklist_proto->add_urls(*it);
   }
 }
 
 }  // namespace
 
-BlacklistStore::BlacklistStore(PrefService* profile_prefs)
-    : pref_service_(profile_prefs) {
+BlacklistStore::BlacklistStore(PrefService* profile_prefs,
+                               const base::TimeDelta& upload_delay)
+    : pref_service_(profile_prefs), upload_delay_(upload_delay) {
   DCHECK(pref_service_);
 
   // Log the blacklist's size. A single BlacklistStore is created for the
   // SuggestionsService; this will run once.
   SuggestionsBlacklist blacklist_proto;
   LoadBlacklist(&blacklist_proto);
   UMA_HISTOGRAM_COUNTS_10000("Suggestions.LocalBlacklistSize",
                              blacklist_proto.urls_size());
 }
 
 BlacklistStore::~BlacklistStore() {}
 
 bool BlacklistStore::BlacklistUrl(const GURL& url) {
   if (!url.is_valid()) return false;
 
   SuggestionsBlacklist blacklist_proto;
   LoadBlacklist(&blacklist_proto);
-
   std::set<std::string> blacklist_set;
   PopulateBlacklistSet(blacklist_proto, &blacklist_set);
 
-  if (!blacklist_set.insert(url.spec()).second) {
+  bool success = false;
+  if (blacklist_set.insert(url.spec()).second) {
+    PopulateBlacklistProto(blacklist_set, &blacklist_proto);
+    success = StoreBlacklist(blacklist_proto);
+  } else {
     // |url| was already in the blacklist.
+    success = true;
+  }
+
+  if (success) {
+    // Update the blacklist time.
+    blacklist_times_[url.spec()] = TimeTicks::Now();
+  }
+
+  return success;
+}
+
+bool BlacklistStore::IsEmpty() {
+  SuggestionsBlacklist blacklist;
+  LoadBlacklist(&blacklist);
+  return blacklist.urls_size() == 0;
+}
+
+bool BlacklistStore::GetTimeUntilReadyForUpload(TimeDelta* delta) {
+  SuggestionsBlacklist blacklist;
+  LoadBlacklist(&blacklist);
+  if (blacklist.urls_size() == 0)

[Mathieu, 2014/12/04 18:53:32]

!blacklist.urls_size() ?

[manzagop (departed), 2014/12/05 15:13:21]

Done.

+    return false;
+
+  // Note: the size is non-negative.
+  if (blacklist_times_.size() < static_cast<size_t>(blacklist.urls_size())) {
+    // A url is not in the timestamp map: it's candidate for upload.

[Mathieu, 2014/12/04 18:53:32]

Indicate that this may happen if the application was restarted (BlacklistStore
should be a singleton so we can assume only a restart would bring us to this
case.)

[manzagop (departed), 2014/12/05 15:13:21]

Done. Good point.

+    *delta = TimeDelta::FromSeconds(0);
     return true;
   }
 
-  PopulateBlacklistProto(blacklist_set, &blacklist_proto);
-  return StoreBlacklist(blacklist_proto);
+  // Find the minimum blacklist time. Note: blacklist_times_ is NOT empty since

[Mathieu, 2014/12/04 18:53:32]

CHECK(blacklist_times_ is not empty) ?

[manzagop (departed), 2014/12/05 15:13:22]

Done.

+  // blacklist is non-empty and blacklist_times_ contains as many items.
+  base::TimeTicks min_time = blacklist_times_.begin()->second;
+  for (const auto& kv : blacklist_times_) {
+    if (kv.second < min_time)
+      min_time = kv.second;
+  }
+  *delta = std::max(upload_delay_ - (TimeTicks::Now() - min_time),
+                    TimeDelta::FromSeconds(0));
+
+  return true;
 }
 
-bool BlacklistStore::GetFirstUrlFromBlacklist(GURL* url) {
+bool BlacklistStore::GetTimeUntilReadyForUpload(const GURL& url,
+                                                TimeDelta* delta) {
+  auto it = blacklist_times_.find(url.spec());
+  if (it != blacklist_times_.end()) {
+    // The url is in the timestamps map.
+    *delta = std::max(upload_delay_ - (TimeTicks::Now() - it->second),
+                      TimeDelta::FromSeconds(0));
+    return true;
+  }
+
+  // The url still might be in the blacklist.
   SuggestionsBlacklist blacklist;
   LoadBlacklist(&blacklist);
-  if (!blacklist.urls_size()) return false;
-  GURL blacklisted(blacklist.urls(0));
-  url->Swap(&blacklisted);
-  return true;
+  for (int i = 0; i < blacklist.urls_size(); ++i) {
+    if (blacklist.urls(i) == url.spec()) {
+      *delta = TimeDelta::FromSeconds(0);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool BlacklistStore::GetCandidateForUpload(GURL* url) {
+  SuggestionsBlacklist blacklist;
+  LoadBlacklist(&blacklist);
+
+  for (int i = 0; i < blacklist.urls_size(); ++i) {
+    bool is_candidate = true;
+    auto it = blacklist_times_.find(blacklist.urls(i));
+    if (it != blacklist_times_.end() &&
+        TimeTicks::Now() < it->second + upload_delay_) {
+      // URL was added too recently.
+      is_candidate = false;
+    }
+    if (is_candidate) {
+      GURL blacklisted(blacklist.urls(i));
+      url->Swap(&blacklisted);
+      return true;
+    }
+  }
+
+  return false;
 }
 
 bool BlacklistStore::RemoveUrl(const GURL& url) {
   if (!url.is_valid()) return false;
   const std::string removal_candidate = url.spec();
 
   SuggestionsBlacklist blacklist;
   LoadBlacklist(&blacklist);
 
+  bool removed = false;
   SuggestionsBlacklist updated_blacklist;
   for (int i = 0; i < blacklist.urls_size(); ++i) {
-    if (blacklist.urls(i) != removal_candidate)
+    if (blacklist.urls(i) == removal_candidate) {
+      removed = true;
+    } else {
       updated_blacklist.add_urls(blacklist.urls(i));
+    }
   }
 
-  return StoreBlacklist(updated_blacklist);
+  if (removed && StoreBlacklist(updated_blacklist)) {
+    blacklist_times_.erase(url.spec());
+    return true;
+  }
+
+  return false;
 }
 
 void BlacklistStore::FilterSuggestions(SuggestionsProfile* profile) {
   if (!profile->suggestions_size())
     return;  // Empty profile, nothing to filter.
 
   SuggestionsBlacklist blacklist_proto;
   if (!LoadBlacklist(&blacklist_proto)) {
     // There was an error loading the blacklist. The blacklist was cleared and
     // there's nothing to be done about it.
@@ skipping 62 matching lines @@
 
   pref_service_->SetString(prefs::kSuggestionsBlacklist, base64_blacklist_data);
   return true;
 }
 
 void BlacklistStore::ClearBlacklist() {
   pref_service_->ClearPref(prefs::kSuggestionsBlacklist);
 }
 
 }  // namespace suggestions