Implement origin-based deletion of plugin data

chrome/browser/browsing_data/browsing_data_remover.cc

 // Copyright (c) 2012 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 "chrome/browser/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 96 matching lines @@
 #if defined(ENABLE_SESSION_SERVICE)
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #endif
 
 #if defined(ENABLE_WEBRTC)
 #include "chrome/browser/media/webrtc_log_list.h"
 #include "chrome/browser/media/webrtc_log_util.h"
 #endif
 
+#if defined(ENABLE_PLUGINS)

[Bernhard Bauer, 2016/08/18 18:35:59]

Move this between ENABLE_EXTENSIONS and ENABLE_SESSION_SERVICE?

[msramek, 2016/08/19 11:16:46]

Done. Also moved the "OS_CHROMEOS" section down. If I disregard sorting, it's
usually because the list is already unsorted :)

+#include "chrome/browser/browsing_data/browsing_data_flash_lso_helper.h"
+#endif
+
 using base::UserMetricsAction;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DOMStorageContext;
 
 namespace {
 
 void UIThreadTrampolineHelper(const base::Closure& callback) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
@@ skipping 155 matching lines @@
     case browsing_data::ALL_TIME:
       content::RecordAction(UserMetricsAction("ClearBrowsingData_Everything"));
       break;
   }
   return TimeRange(CalculateBeginDeleteTime(period), base::Time::Max());
 }
 
 BrowsingDataRemover::BrowsingDataRemover(
     content::BrowserContext* browser_context)
     : profile_(Profile::FromBrowserContext(browser_context)),
-      is_removing_(false),
       remove_mask_(-1),
       origin_type_mask_(-1),
+      is_removing_(false),
+#if defined(ENABLE_PLUGINS)
+      flash_lso_helper_(BrowsingDataFlashLSOHelper::Create(profile_)),
+#endif
 #if BUILDFLAG(ANDROID_JAVA_UI)
       webapp_registry_(new WebappRegistry()),
 #endif
       weak_ptr_factory_(this) {
   DCHECK(browser_context);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   if (!task_queue_.empty()) {
     VLOG(1) << "BrowsingDataRemover shuts down with " << task_queue_.size()
@@ skipping 461 matching lines @@
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
   }
 
 #if defined(ENABLE_PLUGINS)
   // Plugin is data not separated for protected and unprotected web origins. We
   // check the origin_type_mask_ to prevent unintended deletion.
   if (remove_mask & REMOVE_PLUGIN_DATA &&
       origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_LSOData"));
+    waiting_for_clear_plugin_data_count_ = 1;
 
-    waiting_for_clear_plugin_data_ = true;
-    DCHECK(!plugin_data_remover_);
-    plugin_data_remover_.reset(content::PluginDataRemover::Create(profile_));
-    base::WaitableEvent* event =
-        plugin_data_remover_->StartRemoving(delete_begin_);
+    if (filter_builder.IsEmptyBlacklist()) {
+      DCHECK(!plugin_data_remover_);
+      plugin_data_remover_.reset(content::PluginDataRemover::Create(profile_));
+      base::WaitableEvent* event =
+          plugin_data_remover_->StartRemoving(delete_begin_);
 
-    base::WaitableEventWatcher::EventCallback watcher_callback =
-        base::Bind(&BrowsingDataRemover::OnWaitableEventSignaled,
-                   weak_ptr_factory_.GetWeakPtr());
-    watcher_.StartWatching(event, watcher_callback);
+      base::WaitableEventWatcher::EventCallback watcher_callback =
+          base::Bind(&BrowsingDataRemover::OnWaitableEventSignaled,
+                     weak_ptr_factory_.GetWeakPtr());
+      watcher_.StartWatching(event, watcher_callback);
+    } else {
+      // TODO(msramek): Store filters from the currently executed task on the
+      // object to avoid having to copy them to callback methods.
+      flash_lso_helper_->StartFetching(base::Bind(
+          &BrowsingDataRemover::OnSitesWithFlashDataFetched,
+          weak_ptr_factory_.GetWeakPtr(),
+          filter_builder.BuildPluginFilter()));
+    }
   }
 #endif
 
   if (remove_mask & REMOVE_SITE_USAGE_DATA) {
     ClearSettingsForOneTypeWithPredicate(
         HostContentSettingsMapFactory::GetForProfile(profile_),
         CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
         base::Bind(&ForwardPrimaryPatternCallback, same_pattern_filter));
   }
 
@@ skipping 304 matching lines @@
   storage_partition_for_testing_ = storage_partition;
 }
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 void BrowsingDataRemover::OverrideWebappRegistryForTesting(
     std::unique_ptr<WebappRegistry> webapp_registry) {
   webapp_registry_.reset(webapp_registry.release());
 }
 #endif
 
+#if defined(ENABLE_PLUGINS)
+void BrowsingDataRemover::OverrideFlashLSOHelperForTesting(
+    scoped_refptr<BrowsingDataFlashLSOHelper> flash_lso_helper) {
+  flash_lso_helper_ = flash_lso_helper;
+}
+#endif
+
 const base::Time& BrowsingDataRemover::GetLastUsedBeginTime() {
   return delete_begin_;
 }
 
 const base::Time& BrowsingDataRemover::GetLastUsedEndTime() {
   return delete_end_;
 }
 
 int BrowsingDataRemover::GetLastUsedRemovalMask() {
   return remove_mask_;
@@ skipping 41 matching lines @@
          !waiting_for_clear_cache_ &&
          !waiting_for_clear_flash_content_licenses_ &&
          !waiting_for_clear_channel_ids_ && !waiting_for_clear_cookies_count_ &&
          !waiting_for_clear_domain_reliability_monitor_ &&
          !waiting_for_clear_form_ && !waiting_for_clear_history_ &&
          !waiting_for_clear_hostname_resolution_cache_ &&
          !waiting_for_clear_keyword_data_ && !waiting_for_clear_nacl_cache_ &&
          !waiting_for_clear_network_predictor_ &&
          !waiting_for_clear_networking_history_ &&
          !waiting_for_clear_passwords_ && !waiting_for_clear_passwords_stats_ &&
-         !waiting_for_clear_platform_keys_ && !waiting_for_clear_plugin_data_ &&
+         !waiting_for_clear_platform_keys_ &&
+         !waiting_for_clear_plugin_data_count_ &&
          !waiting_for_clear_pnacl_cache_ &&
 #if BUILDFLAG(ANDROID_JAVA_UI)
          !waiting_for_clear_precache_history_ &&
          !waiting_for_clear_webapp_data_ &&
          !waiting_for_clear_webapp_history_ &&
          !waiting_for_clear_offline_page_data_ &&
 #endif
 #if defined(ENABLE_WEBRTC)
          !waiting_for_clear_webrtc_logs_ &&
 #endif
@@ skipping 108 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_pnacl_cache_ = false;
   NotifyIfDone();
 }
 #endif
 
 #if defined(ENABLE_PLUGINS)
 void BrowsingDataRemover::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  waiting_for_clear_plugin_data_ = false;
+
+  --waiting_for_clear_plugin_data_count_;

[Bernhard Bauer, 2016/08/18 18:35:59]

I would use post-increment – the compiler should be smart enough anyway to
create the same instructions, and it reads a bit more clearly to me.

[msramek, 2016/08/19 11:16:46]

I replaced this part, but changed it in OnFlashDataDeleted() below.

I also believe that the compiler will optimize it. I just got used to writing
++C that way :)

[Bernhard Bauer, 2016/08/19 16:29:39]

Yeah, if you think about it, C++ means incrementally improving C, then throwing
away the result ;-)

+  DCHECK(!waiting_for_clear_plugin_data_count_);

[Bernhard Bauer, 2016/08/18 18:35:59]

So really, you are transitioning from 1 to 0? Why not be explicit about it?

[msramek, 2016/08/19 11:16:46]

Changed to DCHECK that it's 1, then set it to 0.

My intention was to use decrement so that it's analogous to
OnFlashDataDeleted().

+
   plugin_data_remover_.reset();
   watcher_.StopWatching();
   NotifyIfDone();
 }
 
+void BrowsingDataRemover::OnSitesWithFlashDataFetched(
+    base::Callback<bool(const std::string&)> plugin_filter,
+    const std::vector<std::string>& sites) {
+  --waiting_for_clear_plugin_data_count_;
+  DCHECK(!waiting_for_clear_plugin_data_count_);
+
+  std::vector<std::string> sites_to_delete;
+  for (const std::string& site : sites) {
+    if (plugin_filter.Run(site))
+      sites_to_delete.push_back(site);
+  }
+
+  waiting_for_clear_plugin_data_count_ = sites_to_delete.size();
+
+  for (const std::string& site : sites_to_delete) {
+    flash_lso_helper_->DeleteFlashLSOsForSite(
+        site,
+        base::Bind(&BrowsingDataRemover::OnFlashDataDeleted,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  NotifyIfDone();
+}
+
+void BrowsingDataRemover::OnFlashDataDeleted() {
+  --waiting_for_clear_plugin_data_count_;
+  NotifyIfDone();
+}
+
 void BrowsingDataRemover::OnDeauthorizeFlashContentLicensesCompleted(
     uint32_t request_id,
     bool /* success */) {
   DCHECK(waiting_for_clear_flash_content_licenses_);
   DCHECK_EQ(request_id, deauthorize_flash_content_licenses_request_id_);
 
   waiting_for_clear_flash_content_licenses_ = false;
   NotifyIfDone();
 }
 #endif
@@ skipping 94 matching lines @@
   waiting_for_clear_offline_page_data_ = false;
   NotifyIfDone();
 }
 #endif
 
 void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyIfDone();
 }