Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/browsing_data

chrome/browser/browsing_data/site_data_counting_helper.cc

 // 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"
@@ skipping 31 matching lines @@
 
   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)));
+      base::BindOnce(&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));
+          base::BindOnce(&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);
@@ skipping 22 matching lines @@
       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)));
+      base::BindOnce(&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());
@@ skipping 10 matching lines @@
 
   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>()));
+        base::BindOnce(&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));
+                          base::BindOnce(&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));
+                          base::BindOnce(&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);
@@ skipping 37 matching lines @@
     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));
+                          base::BindOnce(&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()));
+      FROM_HERE, base::BindOnce(completion_callback_, unique_origins_.size()));
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }