BrowsingDataRemover, (re)use StoragePartition deletion code.

chrome/browser/browsing_data/browsing_data_remover_unittest.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 <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/ssl/server_bound_cert_service.h"
 #include "net/ssl/server_bound_cert_store.h"
 #include "net/ssl/ssl_client_cert_type.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/browser/quota/mock_quota_manager.h"
-#include "webkit/browser/quota/quota_manager.h"
-#include "webkit/common/quota/quota_types.h"
 
 using content::BrowserThread;
+using content::StoragePartition;
 
 namespace {
 
 const char kTestOrigin1[] = "http://host1:1/";
 const char kTestOrigin2[] = "http://host2:1/";
 const char kTestOrigin3[] = "http://host3:1/";
 const char kTestOriginExt[] = "chrome-extension://abcdefghijklmnopqrstuvwxyz/";
 const char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/";
 
 // For Autofill.
@@ skipping 11 matching lines @@
 
 const base::FilePath::CharType kDomStorageOrigin2[] =
     FILE_PATH_LITERAL("http_host2_1.localstorage");
 
 const base::FilePath::CharType kDomStorageOrigin3[] =
     FILE_PATH_LITERAL("http_host3_1.localstorage");
 
 const base::FilePath::CharType kDomStorageExt[] = FILE_PATH_LITERAL(
     "chrome-extension_abcdefghijklmnopqrstuvwxyz_0.localstorage");
 
-const quota::StorageType kTemporary = quota::kStorageTypeTemporary;
-const quota::StorageType kPersistent = quota::kStorageTypePersistent;
-
-const quota::QuotaClient::ID kClientFile = quota::QuotaClient::kFileSystem;
-
-void PopulateTestQuotaManagedNonBrowsingData(quota::MockQuotaManager* manager) {
-  manager->AddOrigin(kOriginDevTools, kTemporary, kClientFile, base::Time());
-  manager->AddOrigin(kOriginDevTools, kPersistent, kClientFile, base::Time());
-  manager->AddOrigin(kOriginExt, kTemporary, kClientFile, base::Time());
-  manager->AddOrigin(kOriginExt, kPersistent, kClientFile, base::Time());
-}
-
-void PopulateTestQuotaManagedPersistentData(quota::MockQuotaManager* manager) {
-  manager->AddOrigin(kOrigin2, kPersistent, kClientFile, base::Time());
-  manager->AddOrigin(kOrigin3, kPersistent, kClientFile,
-      base::Time::Now() - base::TimeDelta::FromDays(1));
-
-  EXPECT_FALSE(manager->OriginHasData(kOrigin1, kPersistent, kClientFile));
-  EXPECT_TRUE(manager->OriginHasData(kOrigin2, kPersistent, kClientFile));
-  EXPECT_TRUE(manager->OriginHasData(kOrigin3, kPersistent, kClientFile));
-}
-
-void PopulateTestQuotaManagedTemporaryData(quota::MockQuotaManager* manager) {
-  manager->AddOrigin(kOrigin1, kTemporary, kClientFile, base::Time::Now());
-  manager->AddOrigin(kOrigin3, kTemporary, kClientFile,
-      base::Time::Now() - base::TimeDelta::FromDays(1));
-
-  EXPECT_TRUE(manager->OriginHasData(kOrigin1, kTemporary, kClientFile));
-  EXPECT_FALSE(manager->OriginHasData(kOrigin2, kTemporary, kClientFile));
-  EXPECT_TRUE(manager->OriginHasData(kOrigin3, kTemporary, kClientFile));
-}
-
-void PopulateTestQuotaManagedData(quota::MockQuotaManager* manager) {
-  // Set up kOrigin1 with a temporary quota, kOrigin2 with a persistent
-  // quota, and kOrigin3 with both. kOrigin1 is modified now, kOrigin2
-  // is modified at the beginning of time, and kOrigin3 is modified one day
-  // ago.
-  PopulateTestQuotaManagedPersistentData(manager);
-  PopulateTestQuotaManagedTemporaryData(manager);
-}
-
 class AwaitCompletionHelper : public BrowsingDataRemover::Observer {
  public:
   AwaitCompletionHelper() : start_(false), already_quit_(false) {}
   virtual ~AwaitCompletionHelper() {}
 
   void BlockUntilNotified() {
     if (!already_quit_) {
       DCHECK(!start_);
       start_ = true;
       base::MessageLoop::current()->Run();
@@ skipping 22 matching lines @@
 
  private:
   // Helps prevent from running message_loop, if the callback invoked
   // immediately.
   bool start_;
   bool already_quit_;
 
   DISALLOW_COPY_AND_ASSIGN(AwaitCompletionHelper);
 };
 
+struct StoragePartitionRemovalData {
+  uint32 remove_mask;
+  uint32 quota_storage_remove_mask;
+  GURL remove_origin;
+  base::Time remove_begin;
+  base::Time remove_end;
+  StoragePartition::OriginMatcherFunction origin_matcher;
+
+  StoragePartitionRemovalData() : remove_mask(0),
+                                  quota_storage_remove_mask(0) {}
+};
+
+class TestStoragePartition : public StoragePartition {
+ public:
+  TestStoragePartition() {}
+  virtual ~TestStoragePartition() {}
+
+  // content::StoragePartition implementation.
+  virtual base::FilePath GetPath() OVERRIDE { return base::FilePath(); }
+  virtual net::URLRequestContextGetter* GetURLRequestContext() OVERRIDE {
+    return NULL;
+  }
+  virtual net::URLRequestContextGetter* GetMediaURLRequestContext() OVERRIDE {
+    return NULL;
+  }
+  virtual quota::QuotaManager* GetQuotaManager() OVERRIDE {
+    return NULL;
+  }
+  virtual appcache::AppCacheService* GetAppCacheService() OVERRIDE {
+    return NULL;
+  }
+  virtual fileapi::FileSystemContext* GetFileSystemContext() OVERRIDE {
+    return NULL;
+  }
+  virtual webkit_database::DatabaseTracker* GetDatabaseTracker() OVERRIDE {
+    return NULL;
+  }
+  virtual content::DOMStorageContext* GetDOMStorageContext() OVERRIDE {
+    return NULL;
+  }
+  virtual content::IndexedDBContext* GetIndexedDBContext() OVERRIDE {
+    return NULL;
+  }
+
+  virtual void ClearDataForOrigin(
+      uint32 remove_mask,
+      uint32 quota_storage_remove_mask,
+      const GURL& storage_origin,
+      net::URLRequestContextGetter* rq_context) OVERRIDE {}
+
+  virtual void ClearData(uint32 remove_mask,
+                         uint32 quota_storage_remove_mask,
+                         const GURL* storage_origin,
+                         const OriginMatcherFunction& origin_matcher,
+                         const base::Time begin,
+                         const base::Time end,
+                         const base::Closure& 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_origin =
+        storage_origin ? *storage_origin : GURL();
+    storage_partition_removal_data_.remove_begin = begin;
+    storage_partition_removal_data_.remove_end = end;
+    storage_partition_removal_data_.origin_matcher = origin_matcher;
+
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&TestStoragePartition::AsyncRunCallback,
+                   base::Unretained(this), callback));
+  }
+
+  StoragePartitionRemovalData GetStoragePartitionRemovalData() {
+    return storage_partition_removal_data_;
+  }
+ private:
+  void AsyncRunCallback(const base::Closure& callback) {
+    callback.Run();
+  }
+
+  StoragePartitionRemovalData storage_partition_removal_data_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestStoragePartition);
+};
+
 }  // namespace
 
 // Testers -------------------------------------------------------------------
 
 class RemoveCookieTester {
  public:
   RemoveCookieTester() : get_cookie_success_(false), monster_(NULL) {
   }
 
   // Returns true, if the given cookie exists in the cookie store.
@@ skipping 383 matching lines @@
     // Otherwise we leak memory.
     profile_.reset();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void BlockUntilBrowsingDataRemoved(BrowsingDataRemover::TimePeriod period,
                                      int remove_mask,
                                      bool include_protected_origins) {
     BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
         profile_.get(), period);
-    remover->OverrideQuotaManagerForTesting(GetMockManager());
 
     AwaitCompletionHelper await_completion;
     remover->AddObserver(&await_completion);
 
     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
 
     // BrowsingDataRemover deletes itself when it completes.
     int origin_set_mask = BrowsingDataHelper::UNPROTECTED_WEB;
     if (include_protected_origins)
       origin_set_mask |= BrowsingDataHelper::PROTECTED_WEB;
     remover->Remove(remove_mask, origin_set_mask);
     await_completion.BlockUntilNotified();
   }
 
   void BlockUntilOriginDataRemoved(BrowsingDataRemover::TimePeriod period,
                                    int remove_mask,
                                    const GURL& remove_origin) {
     BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
         profile_.get(), period);
-    remover->OverrideQuotaManagerForTesting(GetMockManager());
 
     AwaitCompletionHelper await_completion;
     remover->AddObserver(&await_completion);
 
     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
 
     // BrowsingDataRemover deletes itself when it completes.
     remover->RemoveImpl(remove_mask, remove_origin,
         BrowsingDataHelper::UNPROTECTED_WEB);
     await_completion.BlockUntilNotified();
   }
 
+  void BlockUntilStoragePartitionDataRemoved(
+      BrowsingDataRemover::TimePeriod period,
+      int remove_mask,
+      bool include_protected_origins) {
+    BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
+        profile_.get(), period);
+    TestStoragePartition storage_partition;
+    remover->OverrideStoragePartitionForTesting(&storage_partition);
+
+    AwaitCompletionHelper await_completion;
+    remover->AddObserver(&await_completion);
+
+    called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
+
+    // BrowsingDataRemover deletes itself when it completes.
+    int origin_set_mask = BrowsingDataHelper::UNPROTECTED_WEB;
+    if (include_protected_origins)
+      origin_set_mask |= BrowsingDataHelper::PROTECTED_WEB;
+    remover->Remove(remove_mask, origin_set_mask);
+    await_completion.BlockUntilNotified();
+
+    // Save so we can verify later.
+    storage_partition_removal_data_ =
+        storage_partition.GetStoragePartitionRemovalData();
+  }
+
+  void BlockUntilStoragePartitionDataForOriginRemoved(
+      BrowsingDataRemover::TimePeriod period,
+      int remove_mask,
+      const GURL& remove_origin) {
+    BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
+        profile_.get(), period);
+    TestStoragePartition storage_partition;
+    remover->OverrideStoragePartitionForTesting(&storage_partition);
+
+    AwaitCompletionHelper await_completion;
+    remover->AddObserver(&await_completion);
+
+    called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
+
+    // BrowsingDataRemover deletes itself when it completes.
+    remover->RemoveImpl(remove_mask, remove_origin,
+        BrowsingDataHelper::UNPROTECTED_WEB);
+    await_completion.BlockUntilNotified();
+
+    // Save so we can verify later.
+    storage_partition_removal_data_ =
+        storage_partition.GetStoragePartitionRemovalData();
+  }
+
   TestingProfile* GetProfile() {
     return profile_.get();
   }
 
   base::Time GetBeginTime() {
     return called_with_details_->removal_begin;
   }
 
   int GetRemovalMask() {
     return called_with_details_->removal_mask;
   }
 
   int GetOriginSetMask() {
     return called_with_details_->origin_set_mask;
   }
 
-  quota::MockQuotaManager* GetMockManager() {
-    if (!quota_manager_.get()) {
-      quota_manager_ = new quota::MockQuotaManager(
-          profile_->IsOffTheRecord(),
-          profile_->GetPath(),
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(),
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB).get(),
-          profile_->GetExtensionSpecialStoragePolicy());
-    }
-    return quota_manager_.get();
+  StoragePartitionRemovalData GetStoragePartitionRemovalData() {
+    return storage_partition_removal_data_;
   }
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     DCHECK_EQ(type, chrome::NOTIFICATION_BROWSING_DATA_REMOVED);
 
     // We're not taking ownership of the details object, but storing a copy of
     // it locally.
     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails(
         *content::Details<BrowsingDataRemover::NotificationDetails>(
             details).ptr()));
 
     registrar_.RemoveAll();
   }
 
  private:
   scoped_ptr<BrowsingDataRemover::NotificationDetails> called_with_details_;
   content::NotificationRegistrar registrar_;
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
-  scoped_refptr<quota::MockQuotaManager> quota_manager_;
+
+  StoragePartitionRemovalData storage_partition_removal_data_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTest);
 };
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookieForever) {
   RemoveProfileCookieTester tester(GetProfile());
 
   tester.AddCookie();
@@ skipping 276 matching lines @@
                                 removal_mask, false);
   EXPECT_EQ(removal_mask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
 
   // Cookie should be gone; history should remain.
   EXPECT_FALSE(cookie_tester.ContainsCookie());
   EXPECT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
 }
 #endif
 
-TEST_F(BrowsingDataRemoverTest, QuotaClientMaskGeneration) {
-  EXPECT_EQ(quota::QuotaClient::kFileSystem,
-            BrowsingDataRemover::GenerateQuotaClientMask(
-                BrowsingDataRemover::REMOVE_FILE_SYSTEMS));
-  EXPECT_EQ(quota::QuotaClient::kDatabase,
-            BrowsingDataRemover::GenerateQuotaClientMask(
-                BrowsingDataRemover::REMOVE_WEBSQL));
-  EXPECT_EQ(quota::QuotaClient::kAppcache,
-            BrowsingDataRemover::GenerateQuotaClientMask(
-                BrowsingDataRemover::REMOVE_APPCACHE));
-  EXPECT_EQ(quota::QuotaClient::kIndexedDatabase,
-            BrowsingDataRemover::GenerateQuotaClientMask(
-                BrowsingDataRemover::REMOVE_INDEXEDDB));
-  EXPECT_EQ(quota::QuotaClient::kFileSystem |
-            quota::QuotaClient::kDatabase |
-            quota::QuotaClient::kAppcache |
-            quota::QuotaClient::kIndexedDatabase,
-            BrowsingDataRemover::GenerateQuotaClientMask(
-                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB));
-}
-
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverBoth) {
-  PopulateTestQuotaManagedData(GetMockManager());
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyTemporary) {
-  PopulateTestQuotaManagedTemporaryData(GetMockManager());
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+      new MockExtensionSpecialStoragePolicy;
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
+
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+
+  // Check that all related origin data would be removed, that is, origin
+  // matcher would match these origin.
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyPersistent) {
-  PopulateTestQuotaManagedPersistentData(GetMockManager());
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+      new MockExtensionSpecialStoragePolicy;
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
+
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+
+  // Check that all related origin data would be removed, that is, origin
+  // matcher would match these origin.
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverNeither) {
-  GetMockManager();  // Creates the QuotaManager instance.
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+      new MockExtensionSpecialStoragePolicy;
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
 
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+
+  // Check that all related origin data would be removed, that is, origin
+  // matcher would match these origin.
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverSpecificOrigin) {
-  PopulateTestQuotaManagedData(GetMockManager());
-
   // Remove Origin 1.
-  BlockUntilOriginDataRemoved(BrowsingDataRemover::EVERYTHING,
+  BlockUntilStoragePartitionDataForOriginRemoved(
+      BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, kOrigin1);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_EQ(removal_data.remove_origin, kOrigin1);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastHour) {
-  PopulateTestQuotaManagedData(GetMockManager());
-
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::LAST_HOUR,
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+
+  // Persistent data would be left out since we are not removing from
+  // beginning of time.
+  uint32 expected_quota_mask =
+      ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
+  EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask);
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+  // Check removal begin time.
+  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastWeek) {
-  PopulateTestQuotaManagedData(GetMockManager());
-
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_WEEK,
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::LAST_WEEK,
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+
+  // Persistent data would be left out since we are not removing from
+  // beginning of time.
+  uint32 expected_quota_mask =
+      ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
+  EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask);
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+  // Check removal begin time.
+  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedUnprotectedOrigins) {
   // Protect kOrigin1.
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
       new MockExtensionSpecialStoragePolicy;
   mock_policy->AddProtected(kOrigin1.GetOrigin());
   GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
 
-  PopulateTestQuotaManagedData(GetMockManager());
-
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_WEBSQL |
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+
+  // Check OriginMatcherFunction, |kOrigin1| would not match mask since it
+  // is protected.
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedProtectedSpecificOrigin) {
   // Protect kOrigin1.
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
       new MockExtensionSpecialStoragePolicy;
   mock_policy->AddProtected(kOrigin1.GetOrigin());
   GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
 
-  PopulateTestQuotaManagedData(GetMockManager());
-
   // Try to remove kOrigin1. Expect failure.
-  BlockUntilOriginDataRemoved(BrowsingDataRemover::EVERYTHING,
+  BlockUntilStoragePartitionDataForOriginRemoved(
+      BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, kOrigin1);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_EQ(removal_data.remove_origin, kOrigin1);
+
+  // Check OriginMatcherFunction, |kOrigin1| would not match mask since it
+  // is protected.
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedProtectedOrigins) {
   // Protect kOrigin1.
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
       new MockExtensionSpecialStoragePolicy;
   mock_policy->AddProtected(kOrigin1.GetOrigin());
   GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
 
-  PopulateTestQuotaManagedData(GetMockManager());
-
   // Try to remove kOrigin1. Expect success.
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, true);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::PROTECTED_WEB |
       BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
-      kClientFile));
-  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
-      kClientFile));
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+
+  // Check OriginMatcherFunction, |kOrigin1| would match mask since we
+  // would have 'protected' specified in origin_set_mask.
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
+  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedIgnoreExtensionsAndDevTools) {
-  PopulateTestQuotaManagedNonBrowsingData(GetMockManager());
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+      new MockExtensionSpecialStoragePolicy;
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
 
-  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+  BlockUntilStoragePartitionDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
 
-  // Check that extension and devtools data isn't removed.
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginExt, kTemporary,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginExt, kPersistent,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginDevTools, kTemporary,
-      kClientFile));
-  EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginDevTools, kPersistent,
-      kClientFile));
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            static_cast<uint32>(
+                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            static_cast<uint32>(
+                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
+  EXPECT_TRUE(removal_data.remove_origin.is_empty());
+
+  // Check that extension and devtools data wouldn't be removed, that is,
+  // origin matcher would not match these origin.
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy));
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginDevTools, mock_policy));
 }
 
 TEST_F(BrowsingDataRemoverTest, OriginBasedHistoryRemoval) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
@@ skipping 79 matching lines @@
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::LAST_HOUR,
       BrowsingDataRemover::REMOVE_HISTORY, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
   EXPECT_TRUE(tester.HasOrigin(std::string()));
   EXPECT_FALSE(tester.HasOrigin(kWebOrigin));
   EXPECT_TRUE(tester.HasOrigin(kChromeOrigin));
 }