Teaching BrowsingDataRemover how to delete application data.

chrome/browser/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_remover.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/browsing_data_helper.h"
 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/notification_service.h"
 #include "content/test/test_browser_thread.h"
 #include "net/base/server_bound_cert_service.h"
 #include "net/base/server_bound_cert_store.h"
 #include "net/base/ssl_client_cert_type.h"
 #include "net/cookies/cookie_monster.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 "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
+#include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/mock_quota_manager.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 using content::BrowserThread;
 
 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/";
 
 const GURL kOrigin1(kTestOrigin1);
 const GURL kOrigin2(kTestOrigin2);
 const GURL kOrigin3(kTestOrigin3);
 const GURL kOriginExt(kTestOriginExt);
 const GURL kOriginDevTools(kTestOriginDevTools);
 
+const FilePath::CharType kDomStorageOrigin1[] =
+    FILE_PATH_LITERAL("http_host1_1.localstorage");
+
+const FilePath::CharType kDomStorageOrigin2[] =
+    FILE_PATH_LITERAL("http_host2_1.localstorage");
+
+const FilePath::CharType kDomStorageOrigin3[] =
+    FILE_PATH_LITERAL("http_host3_1.localstorage");
+
+const 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;
 const quota::QuotaClient::ID kClientDB = quota::QuotaClient::kIndexedDatabase;
 
 }  // namespace
 
 class BrowsingDataRemoverTester : public BrowsingDataRemover::Observer {
  public:
@@ skipping 220 matching lines @@
   // For History requests.
   CancelableRequestConsumer consumer_;
   bool query_url_success_;
 
   // TestingProfile owns the history service; we shouldn't delete it.
   HistoryService* history_service_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveHistoryTester);
 };
 
+class RemoveLocalStorageTester : public BrowsingDataRemoverTester {
+ public:
+  explicit RemoveLocalStorageTester(TestingProfile* profile)
+      : dom_storage_context_(NULL) {
+    dom_storage_context_ =
+        content::BrowserContext::GetDOMStorageContext(profile);
+  }
+
+  // Returns true, if the given URL exists.
+  bool DOMStorageExistsForOrigin(const GURL& url) {
+    GetLocalStorageFiles();
+    BlockUntilNotified();
+    for (size_t i = 0; i < files_->size(); ++i) {
+      FilePath file_path = (*files_)[i];
+      GURL origin(WebKit::WebSecurityOrigin::createFromDatabaseIdentifier(
+          webkit_glue::FilePathToWebString(file_path.BaseName())).toString());
+      if (origin == url)
+        return true;
+    }
+    return false;
+  }
+
+  void AddDOMStorageTestData() {
+    FilePath storage_path =
+        dom_storage_context_->GetFilePath(
+            ASCIIToUTF16("http_host1_1")).DirName();
+    file_util::CreateDirectory(storage_path);
+
+    // Write some files.
+    file_util::WriteFile(storage_path.Append(kDomStorageOrigin1), NULL, 0);
+    file_util::WriteFile(storage_path.Append(kDomStorageOrigin2), NULL, 0);
+    file_util::WriteFile(storage_path.Append(kDomStorageOrigin3), NULL, 0);
+    file_util::WriteFile(storage_path.Append(kDomStorageExt), NULL, 0);
+
+    // Tweak their dates.
+    file_util::SetLastModifiedTime(storage_path.Append(kDomStorageOrigin1),
+        base::Time::Now());
+    file_util::SetLastModifiedTime(storage_path.Append(kDomStorageOrigin2),
+        base::Time::Now() - base::TimeDelta::FromDays(1));
+    file_util::SetLastModifiedTime(storage_path.Append(kDomStorageOrigin3),
+        base::Time::Now() - base::TimeDelta::FromDays(60));
+    file_util::SetLastModifiedTime(storage_path.Append(kDomStorageExt),
+        base::Time::Now());
+  }
+
+ private:
+  void GetLocalStorageFiles() {
+    dom_storage_context_->GetAllStorageFiles(
+        base::Bind(&RemoveLocalStorageTester::OnGotLocalStorageFiles,
+                   base::Unretained(this)));
+  }
+  void OnGotLocalStorageFiles(const std::vector<FilePath>& files) {
+    files_.reset(new std::vector<FilePath>(files));
+    Notify();
+  }
+
+  // TestingProfile owns the context; we shouldn't delete it.
+  content::DOMStorageContext* dom_storage_context_;
+
+  scoped_ptr<std::vector<FilePath> > files_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveLocalStorageTester);
+};
 class RemoveQuotaManagedDataTester : public BrowsingDataRemoverTester {
  public:
   RemoveQuotaManagedDataTester() {}
   virtual ~RemoveQuotaManagedDataTester() {}
 
   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.
@@ skipping 60 matching lines @@
     // posts a message to the WEBKIT thread to delete some of its member
     // variables. We need to ensure that the profile is destroyed, and that
     // the message loop is cleared out, before destroying the threads and loop.
     // Otherwise we leak memory.
     profile_.reset();
     message_loop_.RunAllPending();
   }
 
   void BlockUntilBrowsingDataRemoved(BrowsingDataRemover::TimePeriod period,
                                      int remove_mask,
+                                     bool include_protected_origins,
                                      BrowsingDataRemoverTester* tester) {
     BrowsingDataRemover* remover = new BrowsingDataRemover(
         profile_.get(), period,
         base::Time::Now() + base::TimeDelta::FromMilliseconds(10));
     remover->OverrideQuotaManagerForTesting(GetMockManager());
     remover->AddObserver(tester);
 
     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
 
     // BrowsingDataRemover deletes itself when it completes.
-    remover->Remove(remove_mask);
+    int origin_set_mask = BrowsingDataHelper::UNPROTECTED_WEB;
+    if (include_protected_origins)
+      origin_set_mask |= BrowsingDataHelper::PROTECTED_WEB;
+    remover->Remove(remove_mask, origin_set_mask);
     tester->BlockUntilNotified();
   }
 
   void BlockUntilOriginDataRemoved(BrowsingDataRemover::TimePeriod period,
                                    int remove_mask,
                                    const GURL& remove_origin,
                                    BrowsingDataRemoverTester* tester) {
     BrowsingDataRemover* remover = new BrowsingDataRemover(
         profile_.get(), period,
         base::Time::Now() + base::TimeDelta::FromMilliseconds(10));
     remover->OverrideQuotaManagerForTesting(GetMockManager());
     remover->AddObserver(tester);
 
     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
 
     // BrowsingDataRemover deletes itself when it completes.
-    remover->RemoveImpl(remove_mask, remove_origin, false);
+    remover->RemoveImpl(remove_mask, remove_origin,
+        BrowsingDataHelper::UNPROTECTED_WEB);
     tester->BlockUntilNotified();
   }
 
   TestingProfile* GetProfile() {
     return profile_.get();
   }
 
   base::Time GetBeginTime() {
     return called_with_details_->removal_begin;
   }
@@ skipping 54 matching lines @@
 // Tests ---------------------------------------------------------------------
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookieForever) {
   scoped_ptr<RemoveProfileCookieTester> tester(
       new RemoveProfileCookieTester(GetProfile()));
 
   tester->AddCookie();
   ASSERT_TRUE(tester->ContainsCookie());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+      BrowsingDataRemover::REMOVE_COOKIES, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_FALSE(tester->ContainsCookie());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookieLastHour) {
   scoped_ptr<RemoveProfileCookieTester> tester(
       new RemoveProfileCookieTester(GetProfile()));
 
   tester->AddCookie();
   ASSERT_TRUE(tester->ContainsCookie());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
-      BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+      BrowsingDataRemover::REMOVE_COOKIES, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_FALSE(tester->ContainsCookie());
 }
 
 #if defined(ENABLE_SAFE_BROWSING)
 TEST_F(BrowsingDataRemoverTest, RemoveSafeBrowsingCookieForever) {
   scoped_ptr<RemoveSafeBrowsingCookieTester> tester(
       new RemoveSafeBrowsingCookieTester());
 
   tester->AddCookie();
   ASSERT_TRUE(tester->ContainsCookie());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+      BrowsingDataRemover::REMOVE_COOKIES, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_FALSE(tester->ContainsCookie());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveSafeBrowsingCookieLastHour) {
   scoped_ptr<RemoveSafeBrowsingCookieTester> tester(
       new RemoveSafeBrowsingCookieTester());
 
   tester->AddCookie();
   ASSERT_TRUE(tester->ContainsCookie());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
-      BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+      BrowsingDataRemover::REMOVE_COOKIES, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   // Removing with time period other than EVERYTHING should not clear safe
   // browsing cookies.
   EXPECT_TRUE(tester->ContainsCookie());
 }
 #endif
 
 TEST_F(BrowsingDataRemoverTest, RemoveServerBoundCertForever) {
   scoped_ptr<RemoveServerBoundCertTester> tester(
       new RemoveServerBoundCertTester(GetProfile()));
 
   tester->AddServerBoundCert(kTestOrigin1);
   EXPECT_EQ(1, tester->ServerBoundCertCount());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, tester.get());
+      BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, GetRemovalMask());
   EXPECT_EQ(0, tester->ServerBoundCertCount());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveServerBoundCertLastHour) {
   scoped_ptr<RemoveServerBoundCertTester> tester(
       new RemoveServerBoundCertTester(GetProfile()));
 
   base::Time now = base::Time::Now();
   tester->AddServerBoundCert(kTestOrigin1);
   tester->AddServerBoundCertWithTimes(kTestOrigin2,
                                       now - base::TimeDelta::FromHours(2),
                                       now);
   EXPECT_EQ(2, tester->ServerBoundCertCount());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
-      BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, tester.get());
+      BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, GetRemovalMask());
   EXPECT_EQ(1, tester->ServerBoundCertCount());
   net::ServerBoundCertStore::ServerBoundCertList certs;
   tester->GetCertStore()->GetAllServerBoundCerts(&certs);
   EXPECT_EQ(kTestOrigin2, certs.front().server_identifier());
 }
 
+TEST_F(BrowsingDataRemoverTest, RemoveUnprotectedLocalStorageForever) {
+  // Protect kOrigin1.
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+          new MockExtensionSpecialStoragePolicy;
+  mock_policy->AddProtected(kOrigin1.GetOrigin());
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy);
+
+  scoped_ptr<RemoveLocalStorageTester> tester(
+      new RemoveLocalStorageTester(GetProfile()));
+
+  tester->AddDOMStorageTestData();
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin2));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin3));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOriginExt));
+
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+      BrowsingDataRemover::REMOVE_LOCAL_STORAGE, false, &tester_);
+
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin1));
+  EXPECT_FALSE(tester->DOMStorageExistsForOrigin(kOrigin2));
+  EXPECT_FALSE(tester->DOMStorageExistsForOrigin(kOrigin3));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOriginExt));
+}
+
+TEST_F(BrowsingDataRemoverTest, RemoveProtectedLocalStorageForever) {
+  // Protect kOrigin1.
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+          new MockExtensionSpecialStoragePolicy;
+  mock_policy->AddProtected(kOrigin1.GetOrigin());
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy);
+
+  scoped_ptr<RemoveLocalStorageTester> tester(
+      new RemoveLocalStorageTester(GetProfile()));
+
+  tester->AddDOMStorageTestData();
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin2));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin3));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOriginExt));
+
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+      BrowsingDataRemover::REMOVE_LOCAL_STORAGE, true, &tester_);
+
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_FALSE(tester->DOMStorageExistsForOrigin(kOrigin1));
+  EXPECT_FALSE(tester->DOMStorageExistsForOrigin(kOrigin2));
+  EXPECT_FALSE(tester->DOMStorageExistsForOrigin(kOrigin3));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOriginExt));
+}
+
+TEST_F(BrowsingDataRemoverTest, RemoveLocalStorageForLastWeek) {
+  scoped_ptr<RemoveLocalStorageTester> tester(
+      new RemoveLocalStorageTester(GetProfile()));
+
+  tester->AddDOMStorageTestData();
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin1));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin2));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin3));
+
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_WEEK,
+      BrowsingDataRemover::REMOVE_LOCAL_STORAGE, false, &tester_);
+
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_FALSE(tester->DOMStorageExistsForOrigin(kOrigin1));
+  EXPECT_FALSE(tester->DOMStorageExistsForOrigin(kOrigin2));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOrigin3));
+  EXPECT_TRUE(tester->DOMStorageExistsForOrigin(kOriginExt));
+}
+
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForever) {
   scoped_ptr<RemoveHistoryTester> tester(
       new RemoveHistoryTester(GetProfile()));
 
   tester->AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_HISTORY, tester.get());
+      BrowsingDataRemover::REMOVE_HISTORY, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_FALSE(tester->HistoryContainsURL(kOrigin1));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForLastHour) {
   scoped_ptr<RemoveHistoryTester> tester(
       new RemoveHistoryTester(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);
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin2));
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
-      BrowsingDataRemover::REMOVE_HISTORY, tester.get());
+      BrowsingDataRemover::REMOVE_HISTORY, false, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_FALSE(tester->HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester->HistoryContainsURL(kOrigin2));
 }
 
 TEST_F(BrowsingDataRemoverTest, QuotaClientMaskGeneration) {
   EXPECT_EQ(quota::QuotaClient::kFileSystem,
             BrowsingDataRemover::GenerateQuotaClientMask(
                 BrowsingDataRemover::REMOVE_FILE_SYSTEMS));
@@ skipping 13 matching lines @@
             BrowsingDataRemover::GenerateQuotaClientMask(
                 BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
                 BrowsingDataRemover::REMOVE_APPCACHE |
                 BrowsingDataRemover::REMOVE_INDEXEDDB));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverBoth) {
   tester_.PopulateTestQuotaManagedData(GetMockManager());
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, &tester_);
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, false, &tester_);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   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));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyTemporary) {
   tester_.PopulateTestQuotaManagedTemporaryData(GetMockManager());
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, &tester_);
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, false, &tester_);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   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));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyPersistent) {
   tester_.PopulateTestQuotaManagedPersistentData(GetMockManager());
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, &tester_);
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, false, &tester_);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   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));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverNeither) {
   GetMockManager();  // Creates the QuotaManager instance.
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, &tester_);
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, false, &tester_);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   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));
@@ skipping 26 matching lines @@
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent,
       kClientFile));
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent,
       kClientFile));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastHour) {
   tester_.PopulateTestQuotaManagedData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, &tester_);
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, false, &tester_);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   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));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastWeek) {
   tester_.PopulateTestQuotaManagedData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_WEEK,
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, &tester_);
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, false, &tester_);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   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));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedUnprotectedOrigins) {
   // Protect kOrigin1.
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
           new MockExtensionSpecialStoragePolicy;
   mock_policy->AddProtected(kOrigin1.GetOrigin());
   GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy);
 
   tester_.PopulateTestQuotaManagedData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, &tester_);
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, false, &tester_);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_WEBSQL |
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
   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));
@@ skipping 28 matching lines @@
   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));
 }
 
+TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedProtectedOrigins) {
+  // Protect kOrigin1.
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+          new MockExtensionSpecialStoragePolicy;
+  mock_policy->AddProtected(kOrigin1.GetOrigin());
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy);
+
+  tester_.PopulateTestQuotaManagedData(GetMockManager());
+
+  // Try to remove kOrigin1. Expect success.
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+      BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_INDEXEDDB |
+      BrowsingDataRemover::REMOVE_WEBSQL, true, &tester_);
+
+  EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
+      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+      BrowsingDataRemover::REMOVE_INDEXEDDB |
+      BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
+  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));
+}
+
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedIgnoreExtensionsAndDevTools) {
   tester_.PopulateTestQuotaManagedNonBrowsingData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
-      BrowsingDataRemover::REMOVE_WEBSQL, &tester_);
+      BrowsingDataRemover::REMOVE_WEBSQL, false, &tester_);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
       BrowsingDataRemover::REMOVE_INDEXEDDB |
       BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
 
   // Check that extension and devtools data isn't removed.
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginExt, kTemporary,
       kClientFile));
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginExt, kPersistent,
@@ skipping 34 matching lines @@
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin2));
 
   BlockUntilOriginDataRemoved(BrowsingDataRemover::LAST_HOUR,
       BrowsingDataRemover::REMOVE_HISTORY, kOrigin2, tester.get());
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_TRUE(tester->HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester->HistoryContainsURL(kOrigin2));
 }