Convert RemoveDataMask from enum to pointers and split it between content and embedder

chrome/browser/browsing_data/browsing_data_remover_browsertest.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 <stddef.h>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/browser/browsing_data/cache_counter.h"
+#include "chrome/browser/browsing_data/chrome_browsing_data_types.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/browsing_data/core/browsing_data_utils.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/browsing_data_filter_builder.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/download_test_observer.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/transport_security_state.h"
 #include "net/test/embedded_test_server/embedded_test_server.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"
 
 using content::BrowserThread;
 using content::BrowsingDataFilterBuilder;
+using content::BrowsingDataType;
 
 namespace {
 static const char* kExampleHost = "example.com";
 }
 
 class BrowsingDataRemoverBrowserTest : public InProcessBrowserTest {
  public:
   BrowsingDataRemoverBrowserTest() {}
 
   void SetUpOnMainThread() override {
@@ skipping 51 matching lines @@
     CacheCounter counter(profile);
     counter.Init(profile->GetPrefs(),
                  base::Bind(&BrowsingDataRemoverBrowserTest::OnCacheSizeResult,
                             base::Unretained(this), base::Unretained(&run_loop),
                             base::Unretained(&size)));
     counter.Restart();
     run_loop.Run();
     return size;
   }
 
-  void RemoveAndWait(int remove_mask) {
+  void RemoveAndWait(const std::set<const BrowsingDataType*>& remove_mask) {
     BrowsingDataRemover* remover =
         BrowsingDataRemoverFactory::GetForBrowserContext(browser()->profile());
     BrowsingDataRemoverCompletionObserver completion_observer(remover);
     remover->RemoveAndReply(
         base::Time(), base::Time::Max(), remove_mask,
         BrowsingDataHelper::UNPROTECTED_WEB, &completion_observer);
     completion_observer.BlockUntilCompletion();
   }
 
   void RemoveWithFilterAndWait(
-      int remove_mask,
+      const std::set<const BrowsingDataType*>& remove_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
     BrowsingDataRemover* remover =
         BrowsingDataRemoverFactory::GetForBrowserContext(browser()->profile());
     BrowsingDataRemoverCompletionObserver completion_observer(remover);
     remover->RemoveWithFilterAndReply(
         base::Time(), base::Time::Max(), remove_mask,
         BrowsingDataHelper::UNPROTECTED_WEB, std::move(filter_builder),
         &completion_observer);
     completion_observer.BlockUntilCompletion();
   }
@@ skipping 48 matching lines @@
     base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000);
     EXPECT_FALSE(state->ShouldUpgradeToSSL("example.test"));
     state->AddHSTS("example.test", expiry, false);
     EXPECT_TRUE(state->ShouldUpgradeToSSL("example.test"));
   }
 };
 
 // Test BrowsingDataRemover for downloads.
 IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverBrowserTest, Download) {
   DownloadAnItem();
-  RemoveAndWait(BrowsingDataRemover::REMOVE_DOWNLOADS);
+  RemoveAndWait({&kBrowsingDataTypeDownloads});
   VerifyDownloadCount(0u);
 }
 
 // The call to Remove() should crash in debug (DCHECK), but the browser-test
 // process model prevents using a death test.
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 // Test BrowsingDataRemover for prohibited downloads. Note that this only
 // really exercises the code in a Release build.
 IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverBrowserTest, DownloadProhibited) {
   PrefService* prefs = browser()->profile()->GetPrefs();
   prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
 
   DownloadAnItem();
-  RemoveAndWait(BrowsingDataRemover::REMOVE_DOWNLOADS);
+  RemoveAndWait({&kBrowsingDataTypeDownloads});
   VerifyDownloadCount(1u);
 }
 #endif
 
 // Verify can modify database after deleting it.
 IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverBrowserTest, Database) {
   GURL url = embedded_test_server()->GetURL("/simple_database.html");
   LOG(ERROR) << url;
   ui_test_utils::NavigateToURL(browser(), url);
 
   RunScriptAndCheckResult("createTable()", "done");
   RunScriptAndCheckResult("insertRecord('text')", "done");
   RunScriptAndCheckResult("getRecords()", "text");
 
-  RemoveAndWait(BrowsingDataRemover::REMOVE_SITE_DATA);
+  RemoveAndWait(BrowsingDataTypeSetSiteData());
 
   ui_test_utils::NavigateToURL(browser(), url);
   RunScriptAndCheckResult("createTable()", "done");
   RunScriptAndCheckResult("insertRecord('text2')", "done");
   RunScriptAndCheckResult("getRecords()", "text2");
 }
 
 // Verify that cache deleting cache finishes successfully. Complete deletion
 // of cache should leave it empty, and partial deletion should leave nonzero
 // amount of data. Note that this tests the integration of BrowsingDataRemover
@@ skipping 10 matching lines @@
 
   // The cache is nonempty, because we created entries by visiting websites.
   browsing_data::BrowsingDataCounter::ResultInt original_size = GetCacheSize();
   EXPECT_GT(original_size, 0);
 
   // Partially delete cache data. Delete data for localhost, which is the origin
   // of |url1|, but not for |kExampleHost|, which is the origin of |url2|.
   std::unique_ptr<BrowsingDataFilterBuilder> filter_builder =
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST);
   filter_builder->AddOrigin(url::Origin(url1));
-  RemoveWithFilterAndWait(BrowsingDataRemover::REMOVE_CACHE,
-                          std::move(filter_builder));
+  RemoveWithFilterAndWait({&kBrowsingDataTypeCache}, std::move(filter_builder));
 
   // After the partial deletion, the cache should be smaller but still nonempty.
   browsing_data::BrowsingDataCounter::ResultInt new_size = GetCacheSize();
   EXPECT_LT(new_size, original_size);
 
   // Another partial deletion with the same filter should have no effect.
   filter_builder =
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST);
   filter_builder->AddOrigin(url::Origin(url1));
-  RemoveWithFilterAndWait(BrowsingDataRemover::REMOVE_CACHE,
-                          std::move(filter_builder));
+  RemoveWithFilterAndWait({&kBrowsingDataTypeCache}, std::move(filter_builder));
   EXPECT_EQ(new_size, GetCacheSize());
 
   // Delete the remaining data.
-  RemoveAndWait(BrowsingDataRemover::REMOVE_CACHE);
+  RemoveAndWait({&kBrowsingDataTypeCache});
 
   // The cache is empty.
   EXPECT_EQ(0, GetCacheSize());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverBrowserTest,
                        ExternalProtocolHandlerPrefs) {
   Profile* profile = browser()->profile();
   base::DictionaryValue prefs;
   prefs.SetBoolean("tel", true);
   profile->GetPrefs()->Set(prefs::kExcludedSchemes, prefs);
   ExternalProtocolHandler::BlockState block_state =
       ExternalProtocolHandler::GetBlockState("tel", profile);
   ASSERT_EQ(ExternalProtocolHandler::BLOCK, block_state);
-  RemoveAndWait(BrowsingDataRemover::REMOVE_SITE_DATA);
+  RemoveAndWait(BrowsingDataTypeSetSiteData());
   block_state = ExternalProtocolHandler::GetBlockState("tel", profile);
   ASSERT_EQ(ExternalProtocolHandler::UNKNOWN, block_state);
 }
 
-// Verify that TransportSecurityState data is cleared for REMOVE_CACHE.
+// Verify that TransportSecurityState data is cleared
+// for kBrowsingDataTypeCache.
 IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverTransportSecurityStateBrowserTest,
                        ClearTransportSecurityState) {
-  RemoveAndWait(BrowsingDataRemover::REMOVE_CACHE);
+  RemoveAndWait({&kBrowsingDataTypeCache});
   base::RunLoop run_loop;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&BrowsingDataRemoverTransportSecurityStateBrowserTest::
                      CheckTransportSecurityState,
                  base::Unretained(this),
                  base::RetainedRef(browser()->profile()->GetRequestContext()),
                  true /* should be cleared */),
       run_loop.QuitClosure());
 }
 
-// Verify that TransportSecurityState data is not cleared if REMOVE_CACHE is not
-// set.
+// Verify that TransportSecurityState data is not cleared
+// if kBrowsingDataTypeCache is not set.
 IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverTransportSecurityStateBrowserTest,
                        PreserveTransportSecurityState) {
-  RemoveAndWait(BrowsingDataRemover::REMOVE_SITE_DATA);
+  RemoveAndWait(BrowsingDataTypeSetSiteData());
   base::RunLoop run_loop;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&BrowsingDataRemoverTransportSecurityStateBrowserTest::
                      CheckTransportSecurityState,
                  base::Unretained(this),
                  base::RetainedRef(browser()->profile()->GetRequestContext()),
                  false /* should not be cleared */),
       run_loop.QuitClosure());
 }