Adding ClearBlackList to the PreviewsBlackList and plumbing to UI

components/previews/core/previews_black_list.cc

 // Copyright 2016 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/previews/core/previews_black_list.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/time/clock.h"
@@ skipping 60 matching lines @@
 bool PreviewsBlackList::IsLoadedAndAllowed(const GURL& url,
                                            PreviewsType type) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(url.has_host());
   if (!loaded_)
     return false;
   PreviewsBlackListItem* black_list_item = GetBlackListItem(url.host());
   return !black_list_item || !black_list_item->IsBlackListed(clock_->Now());
 }
 
+void PreviewsBlackList::ClearBlackList(base::Time begin_time,
+                                       base::Time end_time) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_LE(begin_time, end_time);
+  // If the |black_list_item_map_| has been loaded from |opt_out_store_|,
+  // synchronous operations will be accurate. Otherwise, queue the task to run
+  // asynchronously.
+  if (loaded_) {
+    ClearBlackListSync(begin_time, end_time);
+  } else {
+    QueuePendingTask(base::Bind(&PreviewsBlackList::ClearBlackListSync,
+                                weak_factory_.GetWeakPtr(), begin_time,
+                                end_time));
+  }
+}
+
+void PreviewsBlackList::ClearBlackListSync(base::Time begin_time,
+                                           base::Time end_time) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(loaded_);
+  DCHECK_LE(begin_time, end_time);
+  black_list_item_map_.reset(nullptr);
+  loaded_ = false;
+  // Delete relevant entries and reload the blacklist into memory.
+  if (opt_out_store_) {
+    opt_out_store_->ClearBlackList(begin_time, end_time);

[tbansal1, 2016/10/04 00:16:59]

So, this means that opt out store must execute ClearBlackList  synchronously.
Right?

Alternatively, it might be more flexible if you make this async and let the opt
out store call LoadBlackListDone when it is done clearing the blacklist. 

[tbansal1, 2016/10/04 01:31:46]

Discard this comment.

+    opt_out_store_->LoadBlackList(base::Bind(
+        &PreviewsBlackList::LoadBlackListDone, weak_factory_.GetWeakPtr()));
+  } else {
+    LoadBlackListDone(base::MakeUnique<BlackListItemMap>());
+  }
+}
+
 void PreviewsBlackList::QueuePendingTask(base::Closure callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!loaded_);
   DCHECK(!callback.is_null());
   pending_callbacks_.emplace(callback);
 }
 
 void PreviewsBlackList::LoadBlackListDone(
     std::unique_ptr<BlackListItemMap> black_list_item_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 50 matching lines @@
     }
     if (iter->second->most_recent_opt_out_time().value() < oldest_opt_out) {
       oldest_opt_out = iter->second->most_recent_opt_out_time().value();
       item_to_delete = iter;
     }
   }
   black_list_item_map_->erase(item_to_delete);
 }
 
 }  // namespace previews