Count number of origins with data affected by clearing "cookies and site data".

chrome/browser/browsing_data/site_data_counting_helper.cc

Index: chrome/browser/browsing_data/site_data_counting_helper.cc
diff --git a/chrome/browser/browsing_data/site_data_counting_helper.cc b/chrome/browser/browsing_data/site_data_counting_helper.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b2908c730457bef010b4d358268264ae938783cc
--- /dev/null
+++ b/chrome/browser/browsing_data/site_data_counting_helper.cc
@@ -0,0 +1,246 @@
+// Copyright 2017 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/site_data_counting_helper.h"
+
+#include "chrome/browser/browsing_data/browsing_data_flash_lso_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_helper.h"
+#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/dom_storage_context.h"
+#include "content/public/browser/local_storage_usage_info.h"
+#include "content/public/browser/session_storage_usage_info.h"
+#include "content/public/browser/storage_partition.h"
+#include "net/cookies/cookie_store.h"
+#include "net/cookies/cookie_util.h"
+#include "net/ssl/channel_id_service.h"
+#include "net/ssl/channel_id_store.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "ppapi/features/features.h"
+#include "storage/browser/quota/quota_manager.h"
+
+using content::BrowserThread;
+
+SiteDataCountingHelper::SiteDataCountingHelper(
+    Profile* profile,
+    base::Time begin,
+    base::Callback<void(int)> completion_callback)
+    : profile_(profile),
+      begin_(begin),
+      completion_callback_(completion_callback),
+      tasks_(0) {}
+
+SiteDataCountingHelper::~SiteDataCountingHelper() {}
+
+void SiteDataCountingHelper::CountAndDestroySelfWhenFinished() {
+  content::StoragePartition* partition =
+      content::BrowserContext::GetDefaultStoragePartition(profile_);
+
+  scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy(
+      profile_->GetSpecialStoragePolicy());
+
+  net::URLRequestContextGetter* rq_context = partition->GetURLRequestContext();
+
+  tasks_ += 1;
+  // Count origins with cookies.
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&SiteDataCountingHelper::GetCookiesOnIOThread,
+                 base::Unretained(this), make_scoped_refptr(rq_context)));
+
+  storage::QuotaManager* quota_manager = partition->GetQuotaManager();
+  if (quota_manager) {
+    // Count origins with filesystem, websql, appcache, indexeddb,
+    // serviceworkers and cachestorage using quota manager.
+    storage::GetOriginsCallback origins_callback =
+        base::Bind(&SiteDataCountingHelper::GetQuotaOriginsCallback,
+                   base::Unretained(this));
+    const storage::StorageType types[] = {storage::kStorageTypeTemporary,
+                                          storage::kStorageTypePersistent,
+                                          storage::kStorageTypeSyncable};
+    for (auto type : types) {
+      tasks_ += 1;
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(&storage::QuotaManager::GetOriginsModifiedSince,
+                     quota_manager, type, begin_, origins_callback));
+    }
+  }
+
+  // Count origins with local storage or session storage.
+  content::DOMStorageContext* dom_storage = partition->GetDOMStorageContext();
+  if (dom_storage) {
+    tasks_ += 1;
+    auto local_callback =
+        base::Bind(&SiteDataCountingHelper::GetLocalStorageUsageInfoCallback,
+                   base::Unretained(this), special_storage_policy);
+    dom_storage->GetLocalStorageUsage(local_callback);
+    tasks_ += 1;
+    auto session_callback =
+        base::Bind(&SiteDataCountingHelper::GetSessionStorageUsageInfoCallback,
+                   base::Unretained(this), special_storage_policy);
+    dom_storage->GetSessionStorageUsage(session_callback);
+  }
+
+#if BUILDFLAG(ENABLE_PLUGINS)
+  // Count origins with flash data.
+  flash_lso_helper_ = BrowsingDataFlashLSOHelper::Create(profile_);
+  if (flash_lso_helper_) {
+    tasks_ += 1;
+    flash_lso_helper_->StartFetching(
+        base::Bind(&SiteDataCountingHelper::SitesWithFlashDataCallback,
+                   base::Unretained(this)));
+  }
+#endif
+
+  // Counting site usage data and durable permissions.
+  auto* hcsm = HostContentSettingsMapFactory::GetForProfile(profile_);
+  const ContentSettingsType content_settings[] = {
+      CONTENT_SETTINGS_TYPE_DURABLE_STORAGE,
+      CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, CONTENT_SETTINGS_TYPE_APP_BANNER};
+  for (auto type : content_settings) {
+    tasks_ += 1;
+    GetOriginsFromHostContentSettignsMap(hcsm, type);
+  }
+  // Count origins with channel ids.
+  tasks_ += 1;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&SiteDataCountingHelper::GetChannelIDsOnIOThread,
+                 base::Unretained(this), make_scoped_refptr(rq_context)));
+}
+
+void SiteDataCountingHelper::GetOriginsFromHostContentSettignsMap(
+    HostContentSettingsMap* hcsm,
+    ContentSettingsType type) {
+  std::set<GURL> origins;
+  ContentSettingsForOneType settings;
+  hcsm->GetSettingsForOneType(type, std::string(), &settings);
+  for (const ContentSettingPatternSource& rule : settings) {
+    GURL url(rule.primary_pattern.ToString());
+    if (!url.is_empty()) {
+      origins.insert(url);
+    }
+  }
+  Done(std::vector<GURL>(origins.begin(), origins.end()));
+}
+
+void SiteDataCountingHelper::GetCookiesOnIOThread(
+    const scoped_refptr<net::URLRequestContextGetter>& rq_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  net::CookieStore* cookie_store =
+      rq_context->GetURLRequestContext()->cookie_store();
+
+  if (cookie_store) {
+    cookie_store->GetAllCookiesAsync(base::Bind(
+        &SiteDataCountingHelper::GetCookiesCallback, base::Unretained(this)));
+  } else {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&SiteDataCountingHelper::Done, base::Unretained(this),
+                   std::vector<GURL>()));
+  }
+}
+
+void SiteDataCountingHelper::GetCookiesCallback(
+    const net::CookieList& cookies) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  std::vector<GURL> origins;
+  for (const net::CanonicalCookie& cookie : cookies) {
+    if (cookie.CreationDate() >= begin_) {
+      GURL url = net::cookie_util::CookieOriginToURL(cookie.Domain(),
+                                                     cookie.IsSecure());
+      origins.push_back(url);
+    }
+  }
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&SiteDataCountingHelper::Done,
+                                     base::Unretained(this), origins));
+}
+
+void SiteDataCountingHelper::GetQuotaOriginsCallback(
+    const std::set<GURL>& origin_set,
+    storage::StorageType type) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  std::vector<GURL> origins(origin_set.begin(), origin_set.end());
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&SiteDataCountingHelper::Done,
+                                     base::Unretained(this), origins));
+}
+
+void SiteDataCountingHelper::GetLocalStorageUsageInfoCallback(
+    const scoped_refptr<storage::SpecialStoragePolicy>& policy,
+    const std::vector<content::LocalStorageUsageInfo>& infos) {
+  std::vector<GURL> origins;
+  for (const auto& info : infos) {
+    if (info.last_modified >= begin_ &&
+        (!policy || !policy->IsStorageProtected(info.origin))) {
+      origins.push_back(info.origin);
+    }
+  }
+  Done(origins);
+}
+
+void SiteDataCountingHelper::GetSessionStorageUsageInfoCallback(
+    const scoped_refptr<storage::SpecialStoragePolicy>& policy,
+    const std::vector<content::SessionStorageUsageInfo>& infos) {
+  std::vector<GURL> origins;
+  for (const auto& info : infos) {
+    // Session storage doesn't know about creation time.
+    if (!policy || !policy->IsStorageProtected(info.origin)) {
+      origins.push_back(info.origin);
+    }
+  }
+  Done(origins);
+}
+
+void SiteDataCountingHelper::SitesWithFlashDataCallback(
+    const std::vector<std::string>& sites) {
+  std::vector<GURL> origins;
+  for (const std::string& site : sites) {
+    origins.push_back(GURL(site));
+  }
+  Done(origins);
+}
+
+void SiteDataCountingHelper::GetChannelIDsOnIOThread(
+    const scoped_refptr<net::URLRequestContextGetter>& rq_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  net::ChannelIDService* channel_id_service =
+      rq_context->GetURLRequestContext()->channel_id_service();
+  channel_id_service->GetChannelIDStore()->GetAllChannelIDs(base::Bind(
+      &SiteDataCountingHelper::GetChannelIDsCallback, base::Unretained(this)));
+}
+
+void SiteDataCountingHelper::GetChannelIDsCallback(
+    const net::ChannelIDStore::ChannelIDList& channel_ids) {
+  std::vector<GURL> origins;
+  for (const net::ChannelIDStore::ChannelID& channel_id : channel_ids) {
+    if (channel_id.creation_time() >= begin_) {
+      // Assume url is https://<server_identifier> on default port because
+      // channel ids don't know about their scheme or port.
+      origins.push_back(GURL("https://" + channel_id.server_identifier()));
+    }
+  }
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&SiteDataCountingHelper::Done,
+                                     base::Unretained(this), origins));
+}
+
+void SiteDataCountingHelper::Done(const std::vector<GURL>& origins) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(tasks_ > 0);
+  for (const GURL& origin : origins) {
+    unique_origins_.insert(origin);
+  }
+  if (--tasks_ > 0)
+    return;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(completion_callback_, unique_origins_.size()));
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
+}