BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

8 files changed, 250 insertions, 116 deletions

diff --git a/chromium/content/browser/browsing_data/browsing_data_remover_impl.cc b/chromium/content/browser/browsing_data/browsing_data_remover_impl.cc
index d83d797445d..3b27aca5bf4 100644
--- a/chromium/content/browser/browsing_data/browsing_data_remover_impl.cc
+++ b/chromium/content/browser/browsing_data/browsing_data_remover_impl.cc
@@ -19,7 +19,6 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/stl_util.h"
-#include "base/task/post_task.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/browsing_data/browsing_data_filter_builder_impl.h"
@@ -71,7 +70,7 @@ base::OnceClosure RunsOrPostOnCurrentTaskRunner(base::OnceClosure closure) {
 // datatypes, |embedder_matcher| must not be null; the decision for those
 // datatypes will be delegated to it.
 bool DoesOriginMatchMaskAndPredicate(
-    int origin_type_mask,
+    uint64_t origin_type_mask,
     base::OnceCallback<bool(const url::Origin&)> predicate,
     const BrowsingDataRemoverDelegate::EmbedderOriginTypeMatcher&
         embedder_matcher,
@@ -113,8 +112,8 @@ bool DoesOriginMatchMaskAndPredicate(
 BrowsingDataRemoverImpl::BrowsingDataRemoverImpl(
     BrowserContext* browser_context)
     : browser_context_(browser_context),
-      remove_mask_(-1),
-      origin_type_mask_(-1),
+      remove_mask_(0xffffffffffffffffull),
+      origin_type_mask_(0xffffffffffffffffull),
       is_removing_(false),
       storage_partition_for_testing_(nullptr) {
   DCHECK(browser_context_);
@@ -153,7 +152,7 @@ void BrowsingDataRemoverImpl::SetEmbedderDelegate(
 }
 
 bool BrowsingDataRemoverImpl::DoesOriginMatchMaskForTesting(
-    int origin_type_mask,
+    uint64_t origin_type_mask,
     const url::Origin& origin,
     storage::SpecialStoragePolicy* policy) {
   BrowsingDataRemoverDelegate::EmbedderOriginTypeMatcher embedder_matcher;
@@ -167,16 +166,16 @@ bool BrowsingDataRemoverImpl::DoesOriginMatchMaskForTesting(
 
 void BrowsingDataRemoverImpl::Remove(const base::Time& delete_begin,
                                      const base::Time& delete_end,
-                                     int remove_mask,
-                                     int origin_type_mask) {
+                                     uint64_t remove_mask,
+                                     uint64_t origin_type_mask) {
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::unique_ptr<BrowsingDataFilterBuilder>(), nullptr);
 }
 
 void BrowsingDataRemoverImpl::RemoveAndReply(const base::Time& delete_begin,
                                              const base::Time& delete_end,
-                                             int remove_mask,
-                                             int origin_type_mask,
+                                             uint64_t remove_mask,
+                                             uint64_t origin_type_mask,
                                              Observer* observer) {
   DCHECK(observer);
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
@@ -186,8 +185,8 @@ void BrowsingDataRemoverImpl::RemoveAndReply(const base::Time& delete_begin,
 void BrowsingDataRemoverImpl::RemoveWithFilterAndReply(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
-    int origin_type_mask,
+    uint64_t remove_mask,
+    uint64_t origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer) {
   DCHECK(filter_builder);
@@ -199,8 +198,8 @@ void BrowsingDataRemoverImpl::RemoveWithFilterAndReply(
 void BrowsingDataRemoverImpl::RemoveInternal(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
-    int origin_type_mask,
+    uint64_t remove_mask,
+    uint64_t origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer) {
   DCHECK(!observer || observer_list_.HasObserver(observer))
@@ -248,9 +247,8 @@ void BrowsingDataRemoverImpl::RunNextTask() {
   // after a delay.
   slow_pending_tasks_closure_.Reset(base::BindRepeating(
       &BrowsingDataRemoverImpl::RecordUnfinishedSubTasks, GetWeakPtr()));
-  base::PostDelayedTask(FROM_HERE, {BrowserThread::UI},
-                        slow_pending_tasks_closure_.callback(),
-                        kSlowTaskTimeout);
+  GetUIThreadTaskRunner({})->PostDelayedTask(
+      FROM_HERE, slow_pending_tasks_closure_.callback(), kSlowTaskTimeout);
 
   RemoveImpl(removal_task.delete_begin, removal_task.delete_end,
              removal_task.remove_mask, removal_task.filter_builder.get(),
@@ -260,9 +258,9 @@ void BrowsingDataRemoverImpl::RunNextTask() {
 void BrowsingDataRemoverImpl::RemoveImpl(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
+    uint64_t remove_mask,
     BrowsingDataFilterBuilder* filter_builder,
-    int origin_type_mask) {
+    uint64_t origin_type_mask) {
   // =============== README before adding more storage backends ===============
   //
   // If you're adding a data storage backend that is included among
@@ -281,6 +279,7 @@ void BrowsingDataRemoverImpl::RemoveImpl(
   // crbug.com/140910: Many places were calling this with base::Time() as
   // delete_end, even though they should've used base::Time::Max().
   DCHECK_NE(base::Time(), delete_end);
+  DCHECK(domains_for_deferred_cookie_deletion_.empty());
 
   delete_begin_ = delete_begin;
   delete_end_ = delete_end;
@@ -339,6 +338,10 @@ void BrowsingDataRemoverImpl::RemoveImpl(
   if (remove_mask & DATA_TYPE_COOKIES &&
       origin_type_mask_ & ORIGIN_TYPE_UNPROTECTED_WEB) {
     storage_partition_remove_mask |= StoragePartition::REMOVE_DATA_MASK_COOKIES;
+    if (embedder_delegate_) {
+      domains_for_deferred_cookie_deletion_ =
+          embedder_delegate_->GetDomainsForDeferredCookieDeletion(remove_mask);
+    }
   }
   if (remove_mask & DATA_TYPE_LOCAL_STORAGE) {
     storage_partition_remove_mask |=
@@ -389,13 +392,7 @@ void BrowsingDataRemoverImpl::RemoveImpl(
         StoragePartition::REMOVE_DATA_MASK_CONVERSIONS;
   }
 
-  StoragePartition* storage_partition;
-  if (storage_partition_for_testing_) {
-    storage_partition = storage_partition_for_testing_;
-  } else {
-    storage_partition =
-        BrowserContext::GetDefaultStoragePartition(browser_context_);
-  }
+  StoragePartition* storage_partition = GetStoragePartition();
 
   if (storage_partition_remove_mask) {
     uint32_t quota_storage_remove_mask =
@@ -420,6 +417,15 @@ void BrowsingDataRemoverImpl::RemoveImpl(
       deletion_filter = network::mojom::CookieDeletionFilter::New();
     }
 
+    if (!domains_for_deferred_cookie_deletion_.empty()) {
+      // The data types that require deferred deletion are currently not
+      // filterable. If they become filterable we need to check if the
+      // selected domains should actually be deleted.
+      DCHECK(!deletion_filter->excluding_domains.has_value());
+      deletion_filter->excluding_domains =
+          domains_for_deferred_cookie_deletion_;
+    }
+
     BrowsingDataRemoverDelegate::EmbedderOriginTypeMatcher embedder_matcher;
     if (embedder_delegate_)
       embedder_matcher = embedder_delegate_->GetOriginTypeMatcher();
@@ -564,19 +570,19 @@ const base::Time& BrowsingDataRemoverImpl::GetLastUsedBeginTimeForTesting() {
   return delete_begin_;
 }
 
-int BrowsingDataRemoverImpl::GetLastUsedRemovalMaskForTesting() {
+uint64_t BrowsingDataRemoverImpl::GetLastUsedRemovalMaskForTesting() {
   return remove_mask_;
 }
 
-int BrowsingDataRemoverImpl::GetLastUsedOriginTypeMaskForTesting() {
+uint64_t BrowsingDataRemoverImpl::GetLastUsedOriginTypeMaskForTesting() {
   return origin_type_mask_;
 }
 
 BrowsingDataRemoverImpl::RemovalTask::RemovalTask(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
-    int origin_type_mask,
+    uint64_t remove_mask,
+    uint64_t origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer)
     : delete_begin(delete_begin),
@@ -601,6 +607,12 @@ bool BrowsingDataRemoverImpl::RemovalTask::IsSameDeletion(
          *filter_builder == *other.filter_builder;
 }
 
+StoragePartition* BrowsingDataRemoverImpl::GetStoragePartition() {
+  return storage_partition_for_testing_
+             ? storage_partition_for_testing_
+             : BrowserContext::GetDefaultStoragePartition(browser_context_);
+}
+
 void BrowsingDataRemoverImpl::Notify() {
   // Some tests call |RemoveImpl| directly, without using the task scheduler.
   // TODO(msramek): Improve those tests so we don't have to do this. Tests
@@ -653,8 +665,8 @@ void BrowsingDataRemoverImpl::Notify() {
   // Yield to the UI thread before executing the next removal task.
   // TODO(msramek): Consider also adding a backoff if too many tasks
   // are scheduled.
-  base::PostTask(
-      FROM_HERE, {BrowserThread::UI},
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&BrowsingDataRemoverImpl::RunNextTask, GetWeakPtr()));
 }
 
@@ -672,6 +684,24 @@ void BrowsingDataRemoverImpl::OnTaskComplete(TracingDataType data_type) {
   if (!pending_sub_tasks_.empty())
     return;
 
+  // If any cookie deletions have been deferred do them now since all other
+  // tasks are completed.
+  if (!domains_for_deferred_cookie_deletion_.empty()) {
+    DCHECK(remove_mask_ & DATA_TYPE_COOKIES);
+    auto deletion_filter = network::mojom::CookieDeletionFilter::New();
+    deletion_filter->including_domains =
+        std::move(domains_for_deferred_cookie_deletion_);
+    // Moving a vector is defined to empty this vector.
+    DCHECK(domains_for_deferred_cookie_deletion_.empty());
+    GetStoragePartition()->ClearData(
+        StoragePartition::REMOVE_DATA_MASK_COOKIES,
+        /*quota_storage_remove_mask=*/0,
+        /*origin_matcher=*/base::NullCallback(), std::move(deletion_filter),
+        /*perform_storage_cleanup=*/false, delete_begin_, delete_end_,
+        CreateTaskCompletionClosure(TracingDataType::kDeferredCookies));
+    return;
+  }
+
   slow_pending_tasks_closure_.Cancel();
 
   if (!would_complete_callback_.is_null()) {
diff --git a/chromium/content/browser/browsing_data/browsing_data_remover_impl.h b/chromium/content/browser/browsing_data/browsing_data_remover_impl.h
index 34357d25bbc..b1fb5da2a82 100644
--- a/chromium/content/browser/browsing_data/browsing_data_remover_impl.h
+++ b/chromium/content/browser/browsing_data/browsing_data_remover_impl.h
@@ -43,23 +43,23 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
   void SetEmbedderDelegate(
       BrowsingDataRemoverDelegate* embedder_delegate) override;
   bool DoesOriginMatchMaskForTesting(
-      int origin_type_mask,
+      uint64_t origin_type_mask,
       const url::Origin& origin,
       storage::SpecialStoragePolicy* special_storage_policy) override;
   void Remove(const base::Time& delete_begin,
               const base::Time& delete_end,
-              int remove_mask,
-              int origin_type_mask) override;
+              uint64_t remove_mask,
+              uint64_t origin_type_mask) override;
   void RemoveAndReply(const base::Time& delete_begin,
                       const base::Time& delete_end,
-                      int remove_mask,
-                      int origin_type_mask,
+                      uint64_t remove_mask,
+                      uint64_t origin_type_mask,
                       Observer* observer) override;
   void RemoveWithFilterAndReply(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      int remove_mask,
-      int origin_type_mask,
+      uint64_t remove_mask,
+      uint64_t origin_type_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
       Observer* observer) override;
 
@@ -71,8 +71,8 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
           void(base::OnceClosure continue_to_completion)>& callback) override;
 
   const base::Time& GetLastUsedBeginTimeForTesting() override;
-  int GetLastUsedRemovalMaskForTesting() override;
-  int GetLastUsedOriginTypeMaskForTesting() override;
+  uint64_t GetLastUsedRemovalMaskForTesting() override;
+  uint64_t GetLastUsedOriginTypeMaskForTesting() override;
 
   // Used for testing.
   void OverrideStoragePartitionForTesting(StoragePartition* storage_partition);
@@ -82,8 +82,8 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
   virtual void RemoveInternal(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      int remove_mask,
-      int origin_type_mask,
+      uint64_t remove_mask,
+      uint64_t origin_type_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
       Observer* observer);
 
@@ -109,7 +109,8 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
     kNetworkErrorLogging = 11,
     kTrustTokens = 12,
     kConversions = 13,
-    kMaxValue = kConversions,
+    kDeferredCookies = 14,
+    kMaxValue = kDeferredCookies,
   };
 
   // Represents a single removal task. Contains all parameters needed to execute
@@ -118,8 +119,8 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
   struct CONTENT_EXPORT RemovalTask {
     RemovalTask(const base::Time& delete_begin,
                 const base::Time& delete_end,
-                int remove_mask,
-                int origin_type_mask,
+                uint64_t remove_mask,
+                uint64_t origin_type_mask,
                 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
                 Observer* observer);
     RemovalTask(RemovalTask&& other) noexcept;
@@ -131,8 +132,8 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
 
     base::Time delete_begin;
     base::Time delete_end;
-    int remove_mask;
-    int origin_type_mask;
+    uint64_t remove_mask;
+    uint64_t origin_type_mask;
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder;
     std::vector<Observer*> observers;
     base::Time task_started;
@@ -156,9 +157,9 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
   // TODO(crbug.com/589586): Support all backends w/ origin filter.
   void RemoveImpl(const base::Time& delete_begin,
                   const base::Time& delete_end,
-                  int remove_mask,
+                  uint64_t remove_mask,
                   BrowsingDataFilterBuilder* filter_builder,
-                  int origin_type_mask);
+                  uint64_t origin_type_mask);
 
   // Notifies observers and transitions to the idle state.
   void Notify();
@@ -181,6 +182,8 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
   // Records unfinished tasks from |pending_sub_tasks_| after a delay.
   void RecordUnfinishedSubTasks();
 
+  StoragePartition* GetStoragePartition();
+
   // Like GetWeakPtr(), but returns a weak pointer to BrowsingDataRemoverImpl
   // for internal purposes.
   base::WeakPtr<BrowsingDataRemoverImpl> GetWeakPtr();
@@ -198,10 +201,12 @@ class CONTENT_EXPORT BrowsingDataRemoverImpl
   base::Time delete_end_;
 
   // The removal mask for the current removal operation.
-  int remove_mask_ = 0;
+  uint64_t remove_mask_ = 0;
 
   // From which types of origins should we remove data?
-  int origin_type_mask_ = 0;
+  uint64_t origin_type_mask_ = 0;
+
+  std::vector<std::string> domains_for_deferred_cookie_deletion_;
 
   // True if Remove has been invoked.
   bool is_removing_;
diff --git a/chromium/content/browser/browsing_data/browsing_data_remover_impl_browsertest.cc b/chromium/content/browser/browsing_data/browsing_data_remover_impl_browsertest.cc
index 8552434f393..4d9950937f8 100644
--- a/chromium/content/browser/browsing_data/browsing_data_remover_impl_browsertest.cc
+++ b/chromium/content/browser/browsing_data/browsing_data_remover_impl_browsertest.cc
@@ -96,7 +96,7 @@ class BrowsingDataRemoverImplBrowserTest : public ContentBrowserTest {
 
   void SetUpOnMainThread() override {}
 
-  void RemoveAndWait(int remove_mask) {
+  void RemoveAndWait(uint64_t remove_mask) {
     content::BrowsingDataRemover* remover =
         content::BrowserContext::GetBrowsingDataRemover(
             shell()->web_contents()->GetBrowserContext());
@@ -109,7 +109,7 @@ class BrowsingDataRemoverImplBrowserTest : public ContentBrowserTest {
   }
 
   void RemoveWithFilterAndWait(
-      int remove_mask,
+      uint64_t remove_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter) {
     content::BrowsingDataRemover* remover =
         content::BrowserContext::GetBrowsingDataRemover(
diff --git a/chromium/content/browser/browsing_data/browsing_data_remover_impl_unittest.cc b/chromium/content/browser/browsing_data/browsing_data_remover_impl_unittest.cc
index 8000ba6f877..4dbd4690656 100644
--- a/chromium/content/browser/browsing_data/browsing_data_remover_impl_unittest.cc
+++ b/chromium/content/browser/browsing_data/browsing_data_remover_impl_unittest.cc
@@ -26,14 +26,15 @@
 #include "base/strings/strcat.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
-#include "base/task/post_task.h"
 #include "base/test/gmock_callback_support.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/browsing_data_filter_builder.h"
 #include "content/public/browser/browsing_data_remover.h"
+#include "content/public/browser/browsing_data_remover_delegate.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/storage_partition.h"
@@ -165,13 +166,14 @@ class StoragePartitionRemovalTestStoragePartition
                  const base::Time end,
                  base::OnceClosure callback) override {
     // Store stuff to verify parameters' correctness later.
-    storage_partition_removal_data_.remove_mask = remove_mask;
-    storage_partition_removal_data_.quota_storage_remove_mask =
-        quota_storage_remove_mask;
-    storage_partition_removal_data_.remove_begin = begin;
-    storage_partition_removal_data_.remove_end = end;
-
-    base::PostTask(FROM_HERE, {BrowserThread::UI}, std::move(callback));
+    StoragePartitionRemovalData data;
+    data.remove_mask = remove_mask;
+    data.quota_storage_remove_mask = quota_storage_remove_mask;
+    data.remove_begin = begin;
+    data.remove_end = end;
+    storage_partition_removal_data_.push_back(std::move(data));
+
+    GetUIThreadTaskRunner({})->PostTask(FROM_HERE, std::move(callback));
   }
 
   void ClearData(uint32_t remove_mask,
@@ -183,16 +185,16 @@ class StoragePartitionRemovalTestStoragePartition
                  const base::Time end,
                  base::OnceClosure callback) override {
     // Store stuff to verify parameters' correctness later.
-    storage_partition_removal_data_.remove_mask = remove_mask;
-    storage_partition_removal_data_.quota_storage_remove_mask =
-        quota_storage_remove_mask;
-    storage_partition_removal_data_.remove_begin = begin;
-    storage_partition_removal_data_.remove_end = end;
-    storage_partition_removal_data_.origin_matcher = std::move(origin_matcher);
-    storage_partition_removal_data_.cookie_deletion_filter =
-        std::move(cookie_deletion_filter);
-
-    base::PostTask(FROM_HERE, {BrowserThread::UI}, std::move(callback));
+    StoragePartitionRemovalData data;
+    data.remove_mask = remove_mask;
+    data.quota_storage_remove_mask = quota_storage_remove_mask;
+    data.remove_begin = begin;
+    data.remove_end = end;
+    data.origin_matcher = std::move(origin_matcher);
+    data.cookie_deletion_filter = std::move(cookie_deletion_filter);
+    storage_partition_removal_data_.push_back(std::move(data));
+
+    GetUIThreadTaskRunner({})->PostTask(FROM_HERE, std::move(callback));
   }
 
   void ClearCodeCaches(
@@ -200,18 +202,20 @@ class StoragePartitionRemovalTestStoragePartition
       base::Time end,
       const base::RepeatingCallback<bool(const GURL&)>& url_matcher,
       base::OnceClosure callback) override {
-    storage_partition_removal_data_.remove_code_cache = true;
-    storage_partition_removal_data_.remove_begin = begin;
-    storage_partition_removal_data_.remove_end = end;
-    storage_partition_removal_data_.url_matcher = url_matcher;
+    StoragePartitionRemovalData data;
+    data.remove_code_cache = true;
+    data.remove_begin = begin;
+    data.remove_end = end;
+    data.url_matcher = url_matcher;
+    storage_partition_removal_data_.push_back(std::move(data));
   }
 
-  const StoragePartitionRemovalData& GetStoragePartitionRemovalData() const {
-    return storage_partition_removal_data_;
+  std::vector<StoragePartitionRemovalData> GetStoragePartitionRemovalData() {
+    return std::move(storage_partition_removal_data_);
   }
 
  private:
-  StoragePartitionRemovalData storage_partition_removal_data_;
+  std::vector<StoragePartitionRemovalData> storage_partition_removal_data_;
   network::TestNetworkContext network_context_;
 
   DISALLOW_COPY_AND_ASSIGN(StoragePartitionRemovalTestStoragePartition);
@@ -281,6 +285,36 @@ bool FilterMatchesCookie(const CookieDeletionFilterPtr& filter,
   return network::DeletionFilterToInfo(filter.Clone()).Matches(cookie);
 }
 
+class TestBrowsingDataRemoverDelegate
+    : public content::BrowsingDataRemoverDelegate {
+ public:
+  // BrowsingDataRemoverDelegate:
+  std::vector<std::string> GetDomainsForDeferredCookieDeletion(
+      uint64_t remove_mask) override {
+    return deferred_domains_;
+  }
+  BrowsingDataRemoverDelegate::EmbedderOriginTypeMatcher GetOriginTypeMatcher()
+      override {
+    return base::NullCallback();
+  }
+  bool MayRemoveDownloadHistory() override { return false; }
+  void RemoveEmbedderData(const base::Time& delete_begin,
+                          const base::Time& delete_end,
+                          uint64_t remove_mask,
+                          BrowsingDataFilterBuilder* filter_builder,
+                          uint64_t origin_type_mask,
+                          base::OnceClosure callback) override {
+    std::move(callback).Run();
+  }
+
+  void set_deferred_domains(std::vector<std::string> deferred_domains) {
+    deferred_domains_ = deferred_domains;
+  }
+
+ private:
+  std::vector<std::string> deferred_domains_;
+};
+
 }  // namespace
 
 // Testers -------------------------------------------------------------------
@@ -331,7 +365,7 @@ class BrowsingDataRemoverImplTest : public testing::Test {
 
   void BlockUntilBrowsingDataRemoved(const base::Time& delete_begin,
                                      const base::Time& delete_end,
-                                     int remove_mask,
+                                     uint64_t remove_mask,
                                      bool include_protected_origins) {
     // TODO(msramek): Consider moving |storage_partition| to the test fixture.
     StoragePartitionRemovalTestStoragePartition storage_partition;
@@ -342,7 +376,8 @@ class BrowsingDataRemoverImplTest : public testing::Test {
 
     remover_->OverrideStoragePartitionForTesting(&storage_partition);
 
-    int origin_type_mask = BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB;
+    uint64_t origin_type_mask =
+        BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB;
     if (include_protected_origins)
       origin_type_mask |= BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB;
 
@@ -359,7 +394,7 @@ class BrowsingDataRemoverImplTest : public testing::Test {
   void BlockUntilOriginDataRemoved(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      int remove_mask,
+      uint64_t remove_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
     StoragePartitionRemovalTestStoragePartition storage_partition;
 
@@ -389,14 +424,24 @@ class BrowsingDataRemoverImplTest : public testing::Test {
     return remover_->GetLastUsedBeginTimeForTesting();
   }
 
-  int GetRemovalMask() { return remover_->GetLastUsedRemovalMaskForTesting(); }
+  uint64_t GetRemovalMask() {
+    return remover_->GetLastUsedRemovalMaskForTesting();
+  }
 
-  int GetOriginTypeMask() {
+  uint64_t GetOriginTypeMask() {
     return remover_->GetLastUsedOriginTypeMaskForTesting();
   }
 
-  const StoragePartitionRemovalData& GetStoragePartitionRemovalData() const {
-    return storage_partition_removal_data_;
+  // Expects that there is exactly one StoragePartitionRemovalData. Use
+  // GetStoragePartitionRemovalDataList() for zero or multiple deletions.
+  const StoragePartitionRemovalData& GetStoragePartitionRemovalData() {
+    EXPECT_EQ(storage_partition_removal_data_.size(), 1u);
+    return storage_partition_removal_data_.back();
+  }
+
+  std::vector<StoragePartitionRemovalData>
+  GetStoragePartitionRemovalDataListAndReset() {
+    return std::move(storage_partition_removal_data_);
   }
 
   storage::MockSpecialStoragePolicy* CreateMockPolicy() {
@@ -413,7 +458,7 @@ class BrowsingDataRemoverImplTest : public testing::Test {
   }
 
   bool Match(const GURL& origin,
-             int mask,
+             uint64_t mask,
              storage::SpecialStoragePolicy* policy) {
     return remover_->DoesOriginMatchMaskForTesting(
         mask, url::Origin::Create(origin), policy);
@@ -428,7 +473,7 @@ class BrowsingDataRemoverImplTest : public testing::Test {
 
   network::mojom::NetworkContext* network_context_override_ = nullptr;
 
-  StoragePartitionRemovalData storage_partition_removal_data_;
+  std::vector<StoragePartitionRemovalData> storage_partition_removal_data_;
 
   scoped_refptr<storage::MockSpecialStoragePolicy> mock_policy_;
 
@@ -632,8 +677,8 @@ TEST_F(BrowsingDataRemoverImplTest, RemoveMultipleTypes) {
   EXPECT_CALL(*downloads_tester.download_manager(),
               RemoveDownloadsByURLAndTime(_, _, _));
 
-  int removal_mask = BrowsingDataRemover::DATA_TYPE_DOWNLOADS |
-                     BrowsingDataRemover::DATA_TYPE_COOKIES;
+  uint64_t removal_mask = BrowsingDataRemover::DATA_TYPE_DOWNLOADS |
+                          BrowsingDataRemover::DATA_TYPE_COOKIES;
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), removal_mask,
                                 false);
@@ -1267,15 +1312,17 @@ TEST_F(BrowsingDataRemoverImplTest, RemoveCodeCache) {
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::DATA_TYPE_CACHE, false);
-  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
-  EXPECT_TRUE(removal_data.remove_code_cache);
+  auto removal_data = GetStoragePartitionRemovalDataListAndReset();
+  EXPECT_EQ(removal_data.size(), 2u);
+  EXPECT_TRUE(removal_data[1].remove_code_cache);
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveShaderCache) {
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::DATA_TYPE_CACHE, false);
-  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
-  EXPECT_EQ(removal_data.remove_mask,
+  auto removal_data = GetStoragePartitionRemovalDataListAndReset();
+  EXPECT_EQ(removal_data.size(), 2u);
+  EXPECT_EQ(removal_data[0].remove_mask,
             StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE);
 }
 
@@ -1474,7 +1521,7 @@ TEST_F(BrowsingDataRemoverImplTest, MultipleTasksInQuickSuccession) {
       BrowserContext::GetBrowsingDataRemover(GetBrowserContext()));
   EXPECT_FALSE(remover->IsRemovingForTesting());
 
-  int test_removal_masks[] = {
+  uint64_t test_removal_masks[] = {
       BrowsingDataRemover::DATA_TYPE_COOKIES,
       BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
       BrowsingDataRemover::DATA_TYPE_COOKIES,
@@ -1494,7 +1541,7 @@ TEST_F(BrowsingDataRemoverImplTest, MultipleTasksInQuickSuccession) {
       BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
   };
 
-  for (int removal_mask : test_removal_masks) {
+  for (uint64_t removal_mask : test_removal_masks) {
     remover->Remove(base::Time(), base::Time::Max(), removal_mask,
                     BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB);
   }
@@ -1596,4 +1643,58 @@ TEST_F(BrowsingDataRemoverImplTest, ClearsTrustTokensForSiteDespiteTimeRange) {
       BrowsingDataRemover::DATA_TYPE_TRUST_TOKENS, std::move(builder));
 }
 
+TEST_F(BrowsingDataRemoverImplTest, DeferCookieDeletion) {
+  TestBrowsingDataRemoverDelegate delegate;
+  BrowserContext::GetBrowsingDataRemover(GetBrowserContext())
+      ->SetEmbedderDelegate(&delegate);
+  uint32_t dom_storage_mask =
+      StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE |
+      StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+      StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+      StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+      StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+      StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+      StoragePartition::REMOVE_DATA_MASK_BACKGROUND_FETCH |
+      StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
+
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                BrowsingDataRemover::DATA_TYPE_COOKIES |
+                                    BrowsingDataRemover::DATA_TYPE_DOM_STORAGE,
+                                false);
+
+  // Verify storage partition deletion happens once without deferred domains.
+  auto removal_list = GetStoragePartitionRemovalDataListAndReset();
+  EXPECT_EQ(removal_list.size(), 1u);
+  EXPECT_EQ(removal_list[0].remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_COOKIES | dom_storage_mask);
+  EXPECT_FALSE(removal_list[0].cookie_deletion_filter->excluding_domains);
+  EXPECT_FALSE(removal_list[0].cookie_deletion_filter->including_domains);
+
+  // Verify two separate deletions happen with deferred domains.
+  std::vector<std::string> deferred_domains = {"example.com"};
+  delegate.set_deferred_domains(deferred_domains);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                BrowsingDataRemover::DATA_TYPE_COOKIES |
+                                    BrowsingDataRemover::DATA_TYPE_DOM_STORAGE,
+                                false);
+
+  removal_list = GetStoragePartitionRemovalDataListAndReset();
+  EXPECT_EQ(removal_list.size(), 2u);
+  EXPECT_EQ(removal_list[0].remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_COOKIES | dom_storage_mask);
+  EXPECT_EQ(removal_list[1].remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_COOKIES);
+
+  EXPECT_EQ(removal_list[0].cookie_deletion_filter->excluding_domains,
+            deferred_domains);
+  EXPECT_FALSE(removal_list[0].cookie_deletion_filter->including_domains);
+  EXPECT_FALSE(removal_list[1].cookie_deletion_filter->excluding_domains);
+  EXPECT_EQ(removal_list[1].cookie_deletion_filter->including_domains,
+            deferred_domains);
+
+  // Reset delegate.
+  BrowserContext::GetBrowsingDataRemover(GetBrowserContext())
+      ->SetEmbedderDelegate(nullptr);
+}
+
 }  // namespace content
diff --git a/chromium/content/browser/browsing_data/browsing_data_test_utils.cc b/chromium/content/browser/browsing_data/browsing_data_test_utils.cc
index 126b590ee69..9f59d3a2d1b 100644
--- a/chromium/content/browser/browsing_data/browsing_data_test_utils.cc
+++ b/chromium/content/browser/browsing_data/browsing_data_test_utils.cc
@@ -12,12 +12,11 @@
 #include "base/test/bind_test_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/storage_partition.h"
+#include "net/cookies/cookie_inclusion_status.h"
 #include "net/cookies/cookie_util.h"
 #include "services/network/public/mojom/cookie_manager.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using CookieInclusionStatus = net::CanonicalCookie::CookieInclusionStatus;
-
 namespace content {
 
 network::mojom::CookieManager* GetCookieManager(
@@ -46,7 +45,7 @@ void CreateCookieForTest(
       ->SetCanonicalCookie(
           cookie, net::cookie_util::SimulatedCookieSource(cookie, "https"),
           options,
-          base::BindLambdaForTesting([&](CookieInclusionStatus result) {
+          base::BindLambdaForTesting([&](net::CookieInclusionStatus result) {
             result_out = result.IsInclude();
             run_loop.Quit();
           }));
diff --git a/chromium/content/browser/browsing_data/clear_site_data_handler_browsertest.cc b/chromium/content/browser/browsing_data/clear_site_data_handler_browsertest.cc
index ad2efae6b47..c767f7bf3c1 100644
--- a/chromium/content/browser/browsing_data/clear_site_data_handler_browsertest.cc
+++ b/chromium/content/browser/browsing_data/clear_site_data_handler_browsertest.cc
@@ -38,6 +38,7 @@
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
+#include "net/cookies/cookie_inclusion_status.h"
 #include "net/cookies/cookie_store.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/http_request.h"
@@ -86,12 +87,12 @@ class TestBrowsingDataRemoverDelegate : public MockBrowsingDataRemoverDelegate {
                                bool cookies,
                                bool storage,
                                bool cache) {
-    const int kOriginTypeMask =
+    const uint64_t kOriginTypeMask =
         BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
         BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB;
 
     if (cookies) {
-      int data_type_mask =
+      uint64_t data_type_mask =
           BrowsingDataRemover::DATA_TYPE_COOKIES |
           BrowsingDataRemover::DATA_TYPE_AVOID_CLOSING_CONNECTIONS;
 
@@ -102,7 +103,7 @@ class TestBrowsingDataRemoverDelegate : public MockBrowsingDataRemoverDelegate {
                  kOriginTypeMask, &filter_builder);
     }
     if (storage || cache) {
-      int data_type_mask =
+      uint64_t data_type_mask =
           (storage ? BrowsingDataRemover::DATA_TYPE_DOM_STORAGE : 0) |
           (cache ? BrowsingDataRemover::DATA_TYPE_CACHE : 0);
 
@@ -304,9 +305,8 @@ class ClearSiteDataHandlerBrowserTest : public ContentBrowserTest {
   }
 
   // Callback handler for AddCookie().
-  static void AddCookieCallback(
-      base::OnceClosure callback,
-      net::CanonicalCookie::CookieInclusionStatus status) {
+  static void AddCookieCallback(base::OnceClosure callback,
+                                net::CookieInclusionStatus status) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ASSERT_TRUE(status.IsInclude());
     std::move(callback).Run();
diff --git a/chromium/content/browser/browsing_data/clear_site_data_utils.cc b/chromium/content/browser/browsing_data/clear_site_data_utils.cc
index c17c186608f..350c32ec99f 100644
--- a/chromium/content/browser/browsing_data/clear_site_data_utils.cc
+++ b/chromium/content/browser/browsing_data/clear_site_data_utils.cc
@@ -75,7 +75,7 @@ class SiteDataClearer : public BrowsingDataRemover::Observer {
       domain_filter_builder->AddRegisterableDomain(domain);
 
       pending_task_count_++;
-      int remove_mask = BrowsingDataRemover::DATA_TYPE_COOKIES;
+      uint64_t remove_mask = BrowsingDataRemover::DATA_TYPE_COOKIES;
       if (avoid_closing_connections_) {
         remove_mask |= BrowsingDataRemover::DATA_TYPE_AVOID_CLOSING_CONNECTIONS;
       }
@@ -87,7 +87,7 @@ class SiteDataClearer : public BrowsingDataRemover::Observer {
     }
 
     // Delete origin-scoped data.
-    int remove_mask = 0;
+    uint64_t remove_mask = 0;
     if (clear_storage_)
       remove_mask |= BrowsingDataRemover::DATA_TYPE_DOM_STORAGE;
     if (clear_cache_)
diff --git a/chromium/content/browser/browsing_data/same_site_data_remover_impl_unittest.cc b/chromium/content/browser/browsing_data/same_site_data_remover_impl_unittest.cc
index f7b45327720..7e078502439 100644
--- a/chromium/content/browser/browsing_data/same_site_data_remover_impl_unittest.cc
+++ b/chromium/content/browser/browsing_data/same_site_data_remover_impl_unittest.cc
@@ -17,6 +17,7 @@
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_storage_partition.h"
+#include "net/cookies/cookie_inclusion_status.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_util.h"
 #include "net/url_request/url_request_context.h"
@@ -224,11 +225,10 @@ TEST_F(SameSiteDataRemoverImplTest, TestCookieRemovalUnaffectedByParameters) {
   cookie_manager->SetCanonicalCookie(
       cookie1, net::cookie_util::SimulatedCookieSource(cookie1, "https"),
       options,
-      base::BindLambdaForTesting(
-          [&](net::CanonicalCookie::CookieInclusionStatus result) {
-            result_out = result.IsInclude();
-            run_loop1.Quit();
-          }));
+      base::BindLambdaForTesting([&](net::CookieInclusionStatus result) {
+        result_out = result.IsInclude();
+        run_loop1.Quit();
+      }));
   run_loop1.Run();
   EXPECT_TRUE(result_out);
 
@@ -245,11 +245,10 @@ TEST_F(SameSiteDataRemoverImplTest, TestCookieRemovalUnaffectedByParameters) {
   cookie_manager->SetCanonicalCookie(
       cookie2, net::cookie_util::SimulatedCookieSource(cookie2, "https"),
       options,
-      base::BindLambdaForTesting(
-          [&](net::CanonicalCookie::CookieInclusionStatus result) {
-            result_out = result.IsInclude();
-            run_loop2.Quit();
-          }));
+      base::BindLambdaForTesting([&](net::CookieInclusionStatus result) {
+        result_out = result.IsInclude();
+        run_loop2.Quit();
+      }));
   run_loop2.Run();
   EXPECT_TRUE(result_out);