Clear ChannelIDStore using the network service.

Add a new method with filter (by generalizing the ClearCacheUrlFilter)
and time range support to NetworkContext. Use it from
BrowsingDataRemoverImpl.

Also changed some of the Closure parameters in ChannelIDStore to
OnceClosure to more cleanly support calling with the mojo callbacks.

Bug: 824970
Cq-Include-Trybots: master.tryserver.chromium.linux:linux_mojo
Change-Id: I9a8bb37ef80ccda1d048c4c090ebc61855066960
Reviewed-on: https://chromium-review.googlesource.com/1013303
Commit-Queue: Eric Orth <ericorth@chromium.org>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Helen Li <xunjieli@chromium.org>
Reviewed-by: Martin Šrámek <msramek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#552530}

components/mirroring/service/fake_network_service.h

@@ -82,8 +82,12 @@ class MockNetworkContext final : public network::mojom::NetworkContext {
       base::OnceClosure completion_callback) override {}
   void ClearHttpCache(base::Time start_time,
                       base::Time end_time,
-                      network::mojom::ClearCacheUrlFilterPtr filter,
+                      network::mojom::ClearDataFilterPtr filter,
                       ClearHttpCacheCallback callback) override {}
+  void ClearChannelIds(base::Time start_time,
+                       base::Time end_time,
+                       network::mojom::ClearDataFilterPtr filter,
+                       ClearChannelIdsCallback callback) override {}
   void SetNetworkConditions(
       const std::string& profile_id,
       network::mojom::NetworkConditionsPtr conditions) override {}

content/browser/browsing_data/browsing_data_filter_builder_impl.cc

@@ -56,17 +56,6 @@ bool MatchesURL(
           (mode == BrowsingDataFilterBuilder::WHITELIST));
 }
 
-// True if none of the supplied domains matches this Channel ID's server ID
-// and we're a blacklist, or one of them does and we're a whitelist.
-// The whitelist or blacklist is represented as |domains_and_ips| and |mode|.
-bool MatchesChannelIDForRegisterableDomainsAndIPs(
-    const std::set<std::string>& domains_and_ips,
-    BrowsingDataFilterBuilder::Mode mode,
-    const std::string& channel_id_server_id) {
-  return ((mode == BrowsingDataFilterBuilder::WHITELIST) ==
-      (domains_and_ips.find(channel_id_server_id) != domains_and_ips.end()));
-}
-
 // True if none of the supplied domains matches this plugin's |site| and we're
 // a blacklist, or one of them does and we're a whitelist. The whitelist or
 // blacklist is represented by |domains_and_ips| and |mode|.
@@ -138,13 +127,13 @@ BrowsingDataFilterBuilderImpl::BuildGeneralFilter() const {
   return base::BindRepeating(&MatchesURL, origins_, domains_, mode_);
 }
 
-network::mojom::ClearCacheUrlFilterPtr
-BrowsingDataFilterBuilderImpl::BuildClearCacheUrlFilter() const {
-  network::mojom::ClearCacheUrlFilterPtr filter =
-      network::mojom::ClearCacheUrlFilter::New();
+network::mojom::ClearDataFilterPtr
+BrowsingDataFilterBuilderImpl::BuildNetworkServiceFilter() const {
+  network::mojom::ClearDataFilterPtr filter =
+      network::mojom::ClearDataFilter::New();
   filter->type = (mode_ == Mode::WHITELIST)
-                     ? network::mojom::ClearCacheUrlFilter::Type::DELETE_MATCHES
-                     : network::mojom::ClearCacheUrlFilter::Type::KEEP_MATCHES;
+                     ? network::mojom::ClearDataFilter::Type::DELETE_MATCHES
+                     : network::mojom::ClearDataFilter::Type::KEEP_MATCHES;
   filter->origins.insert(filter->origins.begin(), origins_.begin(),
                          origins_.end());
   filter->domains.insert(filter->domains.begin(), domains_.begin(),
@@ -172,15 +161,6 @@ BrowsingDataFilterBuilderImpl::BuildCookieDeletionInfo() const {
   return delete_info;
 }
 
-base::RepeatingCallback<bool(const std::string& channel_id_server_id)>
-BrowsingDataFilterBuilderImpl::BuildChannelIDFilter() const {
-  DCHECK(origins_.empty()) <<
-      "Origin-based deletion is not suitable for channel IDs. Please use "
-      "different scoping, such as RegistrableDomainFilterBuilder.";
-  return base::BindRepeating(&MatchesChannelIDForRegisterableDomainsAndIPs,
-                             domains_, mode_);
-}
-
 base::RepeatingCallback<bool(const std::string& site)>
 BrowsingDataFilterBuilderImpl::BuildPluginFilter() const {
   DCHECK(origins_.empty()) <<

content/browser/browsing_data/browsing_data_filter_builder_impl.h

@@ -24,11 +24,8 @@ class CONTENT_EXPORT BrowsingDataFilterBuilderImpl
   bool IsEmptyBlacklist() const override;
   base::RepeatingCallback<bool(const GURL&)>
       BuildGeneralFilter() const override;
-  network::mojom::ClearCacheUrlFilterPtr BuildClearCacheUrlFilter()
-      const override;
+  network::mojom::ClearDataFilterPtr BuildNetworkServiceFilter() const override;
   net::CookieStore::CookieDeletionInfo BuildCookieDeletionInfo() const override;
-  base::RepeatingCallback<bool(const std::string& server_id)>
-      BuildChannelIDFilter() const override;
   base::RepeatingCallback<bool(const std::string& site)>
       BuildPluginFilter() const override;
   Mode GetMode() const override;

content/browser/browsing_data/browsing_data_filter_builder_impl_unittest.cc

@@ -11,6 +11,7 @@
 
 #include "base/callback.h"
 #include "net/cookies/canonical_cookie.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
@@ -301,68 +302,42 @@ TEST(BrowsingDataFilterBuilderImplTest,
     RunTestCase(test_case, builder.BuildCookieDeletionInfo());
 }
 
-TEST(BrowsingDataFilterBuilderImplTest,
-     RegistrableDomainMatchesChannelIDsWhitelist) {
+TEST(BrowsingDataFilterBuilderImplTest, NetworkServiceFilterWhitelist) {
   BrowsingDataFilterBuilderImpl builder(
       BrowsingDataFilterBuilderImpl::WHITELIST);
+  ASSERT_EQ(BrowsingDataFilterBuilderImpl::WHITELIST, builder.GetMode());
   builder.AddRegisterableDomain(std::string(kGoogleDomain));
   builder.AddRegisterableDomain(std::string(kLongETLDDomain));
   builder.AddRegisterableDomain(std::string(kIPAddress));
   builder.AddRegisterableDomain(std::string(kUnknownRegistryDomain));
   builder.AddRegisterableDomain(std::string(kInternalHostname));
-  base::Callback<bool(const std::string&)> filter =
-      builder.BuildChannelIDFilter();
-
-  TestCase test_cases[] = {
-      // Channel ID server identifiers can be second level domains, ...
-      {"google.com", true},
-      {"website.sp.nom.br", true},
-      {"second-level-domain.fileserver", true},
-
-      // ... IP addresses, or internal hostnames.
-      {"192.168.1.1", true},
-      {"fileserver", true},
-
-      // Channel IDs not in the whitelist are not matched.
-      {"example.com", false},
-      {"192.168.1.2", false},
-      {"website.fileserver", false},
-  };
-
-  for (TestCase test_case : test_cases)
-    RunTestCase(test_case, filter);
+  network::mojom::ClearDataFilterPtr filter =
+      builder.BuildNetworkServiceFilter();
+
+  EXPECT_EQ(network::mojom::ClearDataFilter_Type::DELETE_MATCHES, filter->type);
+  EXPECT_THAT(filter->domains, testing::UnorderedElementsAre(
+                                   kGoogleDomain, kLongETLDDomain, kIPAddress,
+                                   kUnknownRegistryDomain, kInternalHostname));
+  EXPECT_TRUE(filter->origins.empty());
 }
 
-TEST(BrowsingDataFilterBuilderImplTest,
-     RegistrableDomainMatchesChannelIDsBlacklist) {
+TEST(BrowsingDataFilterBuilderImplTest, NetworkServiceFilterBlacklist) {
   BrowsingDataFilterBuilderImpl builder(
       BrowsingDataFilterBuilderImpl::BLACKLIST);
+  ASSERT_EQ(BrowsingDataFilterBuilderImpl::BLACKLIST, builder.GetMode());
   builder.AddRegisterableDomain(std::string(kGoogleDomain));
   builder.AddRegisterableDomain(std::string(kLongETLDDomain));
   builder.AddRegisterableDomain(std::string(kIPAddress));
   builder.AddRegisterableDomain(std::string(kUnknownRegistryDomain));
   builder.AddRegisterableDomain(std::string(kInternalHostname));
-  base::Callback<bool(const std::string&)> filter =
-      builder.BuildChannelIDFilter();
-
-  TestCase test_cases[] = {
-      // Channel ID server identifiers can be second level domains, ...
-      {"google.com", false},
-      {"website.sp.nom.br", false},
-      {"second-level-domain.fileserver", false},
-
-      // ...IP addresses, or internal hostnames.
-      {"192.168.1.1", false},
-      {"fileserver", false},
-
-      // Channel IDs that are not blacklisted are matched.
-      {"example.com", true},
-      {"192.168.1.2", true},
-      {"website.fileserver", true},
-  };
-
-  for (TestCase test_case : test_cases)
-    RunTestCase(test_case, filter);
+  network::mojom::ClearDataFilterPtr filter =
+      builder.BuildNetworkServiceFilter();
+
+  EXPECT_EQ(network::mojom::ClearDataFilter_Type::KEEP_MATCHES, filter->type);
+  EXPECT_THAT(filter->domains, testing::UnorderedElementsAre(
+                                   kGoogleDomain, kLongETLDDomain, kIPAddress,
+                                   kUnknownRegistryDomain, kInternalHostname));
+  EXPECT_TRUE(filter->origins.empty());
 }
 
 TEST(BrowsingDataFilterBuilderImplTest,

content/browser/browsing_data/browsing_data_remover_impl.cc

@@ -119,34 +119,31 @@ void ClearHttpAuthCacheOnIOThread(
   http_session->CloseAllConnections();
 }
 
-void OnClearedChannelIDsOnIOThread(net::URLRequestContextGetter* rq_context,
-                                   base::OnceClosure callback) {
+void OnClearedChannelIDsOnIOThread(
+    net::URLRequestContextGetter* request_context,
+    base::OnceClosure callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Need to close open SSL connections which may be using the channel ids we
   // are deleting.
   // TODO(mattm): http://crbug.com/166069 Make the server bound cert
   // service/store have observers that can notify relevant things directly.
-  rq_context->GetURLRequestContext()
+  // TODO(ericorth): http://crbug.com/824970 Move this over to the network
+  // service and handle within ClearChannelIds().
+  request_context->GetURLRequestContext()
       ->ssl_config_service()
       ->NotifySSLConfigChange();
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, std::move(callback));
 }
 
-void ClearChannelIDsOnIOThread(
-    const base::Callback<bool(const std::string&)>& domain_predicate,
-    base::Time delete_begin,
-    base::Time delete_end,
+void OnClearedChannelIDs(
     scoped_refptr<net::URLRequestContextGetter> request_context,
     base::OnceClosure callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  net::ChannelIDService* channel_id_service =
-      request_context->GetURLRequestContext()->channel_id_service();
-  channel_id_service->GetChannelIDStore()->DeleteForDomainsCreatedBetween(
-      domain_predicate, delete_begin, delete_end,
-      base::Bind(&OnClearedChannelIDsOnIOThread,
-                 base::RetainedRef(std::move(request_context)),
-                 base::Passed(std::move(callback))));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&OnClearedChannelIDsOnIOThread,
+                     base::RetainedRef(std::move(request_context)),
+                     std::move(callback)));
 }
 
 }  // namespace
@@ -353,16 +350,22 @@ void BrowsingDataRemoverImpl::RemoveImpl(
       !(remove_mask & DATA_TYPE_AVOID_CLOSING_CONNECTIONS) &&
       origin_type_mask_ & ORIGIN_TYPE_UNPROTECTED_WEB) {
     base::RecordAction(UserMetricsAction("ClearBrowsingData_ChannelIDs"));
+
+    network::mojom::ClearDataFilterPtr service_filter =
+        filter_builder.BuildNetworkServiceFilter();
+    DCHECK(service_filter->origins.empty())
+        << "Origin-based deletion is not suitable for channel IDs.";
+
     // Since we are running on the UI thread don't call GetURLRequestContext().
     scoped_refptr<net::URLRequestContextGetter> request_context =
         BrowserContext::GetDefaultStoragePartition(browser_context_)
             ->GetURLRequestContext();
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::BindOnce(&ClearChannelIDsOnIOThread,
-                       filter_builder.BuildChannelIDFilter(), delete_begin_,
-                       delete_end_, std::move(request_context),
-                       CreatePendingTaskCompletionClosure()));
+    BrowserContext::GetDefaultStoragePartition(browser_context_)
+        ->GetNetworkContext()
+        ->ClearChannelIds(
+            delete_begin, delete_end, std::move(service_filter),
+            base::BindOnce(&OnClearedChannelIDs, std::move(request_context),
+                           CreatePendingTaskCompletionClosureForMojo()));
   }
 
   //////////////////////////////////////////////////////////////////////////////
@@ -469,7 +472,7 @@ void BrowsingDataRemoverImpl::RemoveImpl(
       // The clearing of the HTTP cache happens in the network service process
       // when enabled.
       network_context->ClearHttpCache(
-          delete_begin, delete_end, filter_builder.BuildClearCacheUrlFilter(),
+          delete_begin, delete_end, filter_builder.BuildNetworkServiceFilter(),
           CreatePendingTaskCompletionClosureForMojo());
     }
 

content/public/browser/browsing_data_filter_builder.h

@@ -67,9 +67,11 @@ class CONTENT_EXPORT BrowsingDataFilterBuilder {
   virtual base::RepeatingCallback<bool(const GURL&)>
       BuildGeneralFilter() const = 0;
 
-  // Builds a filter that can be used with the network service, more precisely
-  // with NetworkContext.ClearHttpCache().
-  virtual network::mojom::ClearCacheUrlFilterPtr BuildClearCacheUrlFilter()
+  // Builds a filter that can be used with the network service. This uses a Mojo
+  // struct rather than a predicate function (as used by the rest of the filters
+  // built by this class) because we need to be able to pass the filter to the
+  // network service via IPC.
+  virtual network::mojom::ClearDataFilterPtr BuildNetworkServiceFilter()
       const = 0;
 
   // Builds a CookieDeletionInfo object that matches cookies whose sources are
@@ -77,11 +79,6 @@ class CONTENT_EXPORT BrowsingDataFilterBuilder {
   virtual net::CookieStore::CookieDeletionInfo BuildCookieDeletionInfo()
       const = 0;
 
-  // Builds a filter that matches channel IDs whose server identifiers are in
-  // the whitelist, or aren't in the blacklist.
-  virtual base::RepeatingCallback<bool(const std::string& server_id)>
-      BuildChannelIDFilter() const = 0;
-
   // Builds a filter that matches the |site| of a plugin.
   virtual base::RepeatingCallback<bool(const std::string& site)>
       BuildPluginFilter() const = 0;

net/socket/ssl_client_socket_unittest.cc

@@ -692,13 +692,13 @@ class FailingChannelIDStore : public ChannelIDStore {
   }
   void SetChannelID(std::unique_ptr<ChannelID> channel_id) override {}
   void DeleteChannelID(const std::string& server_identifier,
-                       const base::Closure& completion_callback) override {}
+                       base::OnceClosure completion_callback) override {}
   void DeleteForDomainsCreatedBetween(
       const base::Callback<bool(const std::string&)>& domain_predicate,
       base::Time delete_begin,
       base::Time delete_end,
-      const base::Closure& completion_callback) override {}
-  void DeleteAll(const base::Closure& completion_callback) override {}
+      base::OnceClosure completion_callback) override {}
+  void DeleteAll(base::OnceClosure completion_callback) override {}
   void GetAllChannelIDs(const GetChannelIDListCallback& callback) override {}
   int GetChannelIDCount() override { return 0; }
   void SetForceKeepSessionState() override {}
@@ -719,13 +719,13 @@ class AsyncFailingChannelIDStore : public ChannelIDStore {
   }
   void SetChannelID(std::unique_ptr<ChannelID> channel_id) override {}
   void DeleteChannelID(const std::string& server_identifier,
-                       const base::Closure& completion_callback) override {}
+                       base::OnceClosure completion_callback) override {}
   void DeleteForDomainsCreatedBetween(
       const base::Callback<bool(const std::string&)>& domain_predicate,
       base::Time delete_begin,
       base::Time delete_end,
-      const base::Closure& completion_callback) override {}
-  void DeleteAll(const base::Closure& completion_callback) override {}
+      base::OnceClosure completion_callback) override {}
+  void DeleteAll(base::OnceClosure completion_callback) override {}
   void GetAllChannelIDs(const GetChannelIDListCallback& callback) override {}
   int GetChannelIDCount() override { return 0; }
   void SetForceKeepSessionState() override {}

net/ssl/channel_id_store.h

@@ -53,10 +53,11 @@ class NET_EXPORT ChannelIDStore {
 
   typedef std::list<ChannelID> ChannelIDList;
 
-  typedef base::Callback<
+  typedef base::RepeatingCallback<
       void(int, const std::string&, std::unique_ptr<crypto::ECPrivateKey>)>
       GetChannelIDCallback;
-  typedef base::Callback<void(const ChannelIDList&)> GetChannelIDListCallback;
+  typedef base::RepeatingCallback<void(const ChannelIDList&)>
+      GetChannelIDListCallback;
 
   virtual ~ChannelIDStore();
 
@@ -74,9 +75,8 @@ class NET_EXPORT ChannelIDStore {
   virtual void SetChannelID(std::unique_ptr<ChannelID> channel_id) = 0;
 
   // Removes a keypair from the store.
-  virtual void DeleteChannelID(
-      const std::string& server_identifier,
-      const base::Closure& completion_callback) = 0;
+  virtual void DeleteChannelID(const std::string& server_identifier,
+                               base::OnceClosure completion_callback) = 0;
 
   // Deletes the channel ID keypairs that have a creation_date greater than
   // or equal to |delete_begin| and less than |delete_end| and whose server
@@ -86,10 +86,10 @@ class NET_EXPORT ChannelIDStore {
       const base::Callback<bool(const std::string&)>& domain_predicate,
       base::Time delete_begin,
       base::Time delete_end,
-      const base::Closure& completion_callback) = 0;
+      base::OnceClosure completion_callback) = 0;
 
   // Removes all channel ID keypairs from the store.
-  virtual void DeleteAll(const base::Closure& completion_callback) = 0;
+  virtual void DeleteAll(base::OnceClosure completion_callback) = 0;
 
   // Returns all channel ID keypairs.
   virtual void GetAllChannelIDs(const GetChannelIDListCallback& callback) = 0;

net/ssl/default_channel_id_store.cc

@@ -33,15 +33,15 @@ class DefaultChannelIDStore::Task {
   virtual void Run(DefaultChannelIDStore* store) = 0;
 
  protected:
-  void InvokeCallback(base::Closure callback) const;
+  void InvokeCallback(base::OnceClosure callback) const;
 };
 
 DefaultChannelIDStore::Task::~Task() = default;
 
 void DefaultChannelIDStore::Task::InvokeCallback(
-    base::Closure callback) const {
+    base::OnceClosure callback) const {
   if (!callback.is_null())
-    callback.Run();
+    std::move(callback).Run();
 }
 
 // --------------------------------------------------------------------------
@@ -75,8 +75,8 @@ void DefaultChannelIDStore::GetChannelIDTask::Run(
                                 GetChannelIDCallback());
   DCHECK(err != ERR_IO_PENDING);
 
-  InvokeCallback(base::Bind(callback_, err, server_identifier_,
-                            base::Passed(std::move(key_result))));
+  InvokeCallback(base::BindOnce(callback_, err, server_identifier_,
+                                std::move(key_result)));
 }
 
 // --------------------------------------------------------------------------
@@ -109,22 +109,19 @@ class DefaultChannelIDStore::DeleteChannelIDTask
     : public DefaultChannelIDStore::Task {
  public:
   DeleteChannelIDTask(const std::string& server_identifier,
-                      const base::Closure& callback);
+                      base::OnceClosure callback);
   ~DeleteChannelIDTask() override;
   void Run(DefaultChannelIDStore* store) override;
 
  private:
   std::string server_identifier_;
-  base::Closure callback_;
+  base::OnceClosure callback_;
 };
 
-DefaultChannelIDStore::DeleteChannelIDTask::
-    DeleteChannelIDTask(
-        const std::string& server_identifier,
-        const base::Closure& callback)
-        : server_identifier_(server_identifier),
-          callback_(callback) {
-}
+DefaultChannelIDStore::DeleteChannelIDTask::DeleteChannelIDTask(
+    const std::string& server_identifier,
+    base::OnceClosure callback)
+    : server_identifier_(server_identifier), callback_(std::move(callback)) {}
 
 DefaultChannelIDStore::DeleteChannelIDTask::~DeleteChannelIDTask() = default;
 
@@ -132,7 +129,7 @@ void DefaultChannelIDStore::DeleteChannelIDTask::Run(
     DefaultChannelIDStore* store) {
   store->SyncDeleteChannelID(server_identifier_);
 
-  InvokeCallback(callback_);
+  InvokeCallback(std::move(callback_));
 }
 
 // --------------------------------------------------------------------------
@@ -144,7 +141,7 @@ class DefaultChannelIDStore::DeleteForDomainsCreatedBetweenTask
       const base::Callback<bool(const std::string&)>& domain_predicate,
       base::Time delete_begin,
       base::Time delete_end,
-      const base::Closure& callback);
+      base::OnceClosure callback);
   ~DeleteForDomainsCreatedBetweenTask() override;
   void Run(DefaultChannelIDStore* store) override;
 
@@ -152,7 +149,7 @@ class DefaultChannelIDStore::DeleteForDomainsCreatedBetweenTask
   const base::Callback<bool(const std::string&)> domain_predicate_;
   base::Time delete_begin_;
   base::Time delete_end_;
-  base::Closure callback_;
+  base::OnceClosure callback_;
 };
 
 DefaultChannelIDStore::DeleteForDomainsCreatedBetweenTask::
@@ -160,11 +157,11 @@ DefaultChannelIDStore::DeleteForDomainsCreatedBetweenTask::
         const base::Callback<bool(const std::string&)>& domain_predicate,
         base::Time delete_begin,
         base::Time delete_end,
-        const base::Closure& callback)
+        base::OnceClosure callback)
     : domain_predicate_(domain_predicate),
       delete_begin_(delete_begin),
       delete_end_(delete_end),
-      callback_(callback) {}
+      callback_(std::move(callback)) {}
 
 DefaultChannelIDStore::DeleteForDomainsCreatedBetweenTask::
     ~DeleteForDomainsCreatedBetweenTask() = default;
@@ -174,7 +171,7 @@ void DefaultChannelIDStore::DeleteForDomainsCreatedBetweenTask::Run(
   store->SyncDeleteForDomainsCreatedBetween(domain_predicate_, delete_begin_,
                                             delete_end_);
 
-  InvokeCallback(callback_);
+  InvokeCallback(std::move(callback_));
 }
 
 // --------------------------------------------------------------------------
@@ -203,7 +200,7 @@ void DefaultChannelIDStore::GetAllChannelIDsTask::Run(
   ChannelIDList key_list;
   store->SyncGetAllChannelIDs(&key_list);
 
-  InvokeCallback(base::Bind(callback_, key_list));
+  InvokeCallback(base::BindOnce(std::move(callback_), key_list));
 }
 
 // --------------------------------------------------------------------------
@@ -248,24 +245,23 @@ void DefaultChannelIDStore::SetChannelID(
 
 void DefaultChannelIDStore::DeleteChannelID(
     const std::string& server_identifier,
-    const base::Closure& callback) {
+    base::OnceClosure callback) {
   RunOrEnqueueTask(std::unique_ptr<Task>(
-      new DeleteChannelIDTask(server_identifier, callback)));
+      new DeleteChannelIDTask(server_identifier, std::move(callback))));
 }
 
 void DefaultChannelIDStore::DeleteForDomainsCreatedBetween(
     const base::Callback<bool(const std::string&)>& domain_predicate,
     base::Time delete_begin,
     base::Time delete_end,
-    const base::Closure& callback) {
+    base::OnceClosure callback) {
   RunOrEnqueueTask(std::unique_ptr<Task>(new DeleteForDomainsCreatedBetweenTask(
-      domain_predicate, delete_begin, delete_end, callback)));
+      domain_predicate, delete_begin, delete_end, std::move(callback))));
 }
 
-void DefaultChannelIDStore::DeleteAll(
-    const base::Closure& callback) {
+void DefaultChannelIDStore::DeleteAll(base::OnceClosure callback) {
   DeleteForDomainsCreatedBetween(base::Bind(&AllDomainsPredicate), base::Time(),
-                                 base::Time(), callback);
+                                 base::Time(), std::move(callback));
 }
 
 void DefaultChannelIDStore::GetAllChannelIDs(

net/ssl/default_channel_id_store.h

@@ -52,13 +52,13 @@ class NET_EXPORT DefaultChannelIDStore : public ChannelIDStore {
                    const GetChannelIDCallback& callback) override;
   void SetChannelID(std::unique_ptr<ChannelID> channel_id) override;
   void DeleteChannelID(const std::string& server_identifier,
-                       const base::Closure& callback) override;
+                       base::OnceClosure callback) override;
   void DeleteForDomainsCreatedBetween(
       const base::Callback<bool(const std::string&)>& domain_predicate,
       base::Time delete_begin,
       base::Time delete_end,
-      const base::Closure& callback) override;
-  void DeleteAll(const base::Closure& callback) override;
+      base::OnceClosure callback) override;
+  void DeleteAll(base::OnceClosure callback) override;
   void GetAllChannelIDs(const GetChannelIDListCallback& callback) override;
   void Flush() override;
   int GetChannelIDCount() override;

services/network/http_cache_data_remover.cc

@@ -20,7 +20,7 @@ namespace network {
 
 namespace {
 
-bool DoesUrlMatchFilter(mojom::ClearCacheUrlFilter_Type filter_type,
+bool DoesUrlMatchFilter(mojom::ClearDataFilter_Type filter_type,
                         const std::set<url::Origin>& origins,
                         const std::set<std::string>& domains,
                         const GURL& url) {
@@ -34,13 +34,13 @@ bool DoesUrlMatchFilter(mojom::ClearCacheUrlFilter_Type filter_type,
   bool found_origin = (origins.find(url::Origin::Create(url)) != origins.end());
 
   return ((found_domain || found_origin) ==
-          (filter_type == mojom::ClearCacheUrlFilter_Type::DELETE_MATCHES));
+          (filter_type == mojom::ClearDataFilter_Type::DELETE_MATCHES));
 }
 
 }  // namespace
 
 HttpCacheDataRemover::HttpCacheDataRemover(
-    mojom::ClearCacheUrlFilterPtr url_filter,
+    mojom::ClearDataFilterPtr url_filter,
     base::Time delete_begin,
     base::Time delete_end,
     HttpCacheDataRemoverCallback done_callback)
@@ -69,7 +69,7 @@ HttpCacheDataRemover::~HttpCacheDataRemover() = default;
 // static.
 std::unique_ptr<HttpCacheDataRemover> HttpCacheDataRemover::CreateAndStart(
     net::URLRequestContext* url_request_context,
-    mojom::ClearCacheUrlFilterPtr url_filter,
+    mojom::ClearDataFilterPtr url_filter,
     base::Time delete_begin,
     base::Time delete_end,
     HttpCacheDataRemoverCallback done_callback) {

services/network/http_cache_data_remover.h

@@ -41,7 +41,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) HttpCacheDataRemover {
   // interface and might be slow.
   static std::unique_ptr<HttpCacheDataRemover> CreateAndStart(
       net::URLRequestContext* url_request_context,
-      mojom::ClearCacheUrlFilterPtr url_filter,
+      mojom::ClearDataFilterPtr url_filter,
       base::Time delete_begin,
       base::Time delete_end,
       HttpCacheDataRemoverCallback done_callback);
@@ -49,7 +49,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) HttpCacheDataRemover {
   ~HttpCacheDataRemover();
 
  private:
-  HttpCacheDataRemover(mojom::ClearCacheUrlFilterPtr url_filter,
+  HttpCacheDataRemover(mojom::ClearDataFilterPtr url_filter,
                        base::Time delete_begin,
                        base::Time delete_end,
                        HttpCacheDataRemoverCallback done_callback);

services/network/http_cache_data_remover_unittest.cc

@@ -104,7 +104,7 @@ class HttpCacheDataRemoverTest : public testing::Test {
               static_cast<size_t>(backend_->GetEntryCount()));
   }
 
-  void RemoveData(mojom::ClearCacheUrlFilterPtr filter,
+  void RemoveData(mojom::ClearDataFilterPtr filter,
                   base::Time start_time,
                   base::Time end_time) {
     base::RunLoop run_loop;
@@ -158,8 +158,8 @@ TEST_F(HttpCacheDataRemoverTest, ClearAll) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterDeleteByDomain) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::DELETE_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::DELETE_MATCHES;
   filter->domains.push_back("wikipedia.com");
   filter->domains.push_back("google.com");
   RemoveData(std::move(filter), base::Time(), base::Time());
@@ -171,8 +171,8 @@ TEST_F(HttpCacheDataRemoverTest, FilterDeleteByDomain) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterKeepByDomain) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::KEEP_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
   filter->domains.push_back("wikipedia.com");
   filter->domains.push_back("google.com");
   RemoveData(std::move(filter), base::Time(), base::Time());
@@ -184,8 +184,8 @@ TEST_F(HttpCacheDataRemoverTest, FilterKeepByDomain) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterDeleteByOrigin) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::DELETE_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::DELETE_MATCHES;
   filter->origins.push_back(url::Origin::Create(GURL("http://www.google.com")));
   filter->origins.push_back(url::Origin::Create(GURL("http://localhost:1234")));
   RemoveData(std::move(filter), base::Time(), base::Time());
@@ -195,8 +195,8 @@ TEST_F(HttpCacheDataRemoverTest, FilterDeleteByOrigin) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterKeepByOrigin) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::KEEP_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
   filter->origins.push_back(url::Origin::Create(GURL("http://www.google.com")));
   filter->origins.push_back(url::Origin::Create(GURL("http://localhost:1234")));
   RemoveData(std::move(filter), base::Time(), base::Time());
@@ -206,8 +206,8 @@ TEST_F(HttpCacheDataRemoverTest, FilterKeepByOrigin) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterDeleteByDomainAndOrigin) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::DELETE_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::DELETE_MATCHES;
   filter->domains.push_back("wikipedia.com");
   filter->origins.push_back(url::Origin::Create(GURL("http://localhost:1234")));
   RemoveData(std::move(filter), base::Time(), base::Time());
@@ -218,8 +218,8 @@ TEST_F(HttpCacheDataRemoverTest, FilterDeleteByDomainAndOrigin) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterKeepByDomainAndOrigin) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::KEEP_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
   filter->domains.push_back("wikipedia.com");
   filter->origins.push_back(url::Origin::Create(GURL("http://localhost:1234")));
   RemoveData(std::move(filter), base::Time(), base::Time());
@@ -264,8 +264,8 @@ TEST_F(HttpCacheDataRemoverTest, FilterByDateRange) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterDeleteByDomainAndDate) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::DELETE_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::DELETE_MATCHES;
   filter->domains.push_back("google.com");
   filter->domains.push_back("wikipedia.com");
 
@@ -282,8 +282,8 @@ TEST_F(HttpCacheDataRemoverTest, FilterDeleteByDomainAndDate) {
 }
 
 TEST_F(HttpCacheDataRemoverTest, FilterKeepByDomainAndDate) {
-  mojom::ClearCacheUrlFilterPtr filter = mojom::ClearCacheUrlFilter::New();
-  filter->type = mojom::ClearCacheUrlFilter_Type::KEEP_MATCHES;
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
   filter->domains.push_back("google.com");
   filter->domains.push_back("wikipedia.com");
 

services/network/network_context.cc

@@ -98,6 +98,17 @@ class WrappedTestingCertVerifier : public net::CertVerifier {
   }
 };
 
+// Predicate function to determine if the given |channel_id_server_id| matches
+// the |filter_type| and |filter_domains| from a |mojom::ClearDataFilter|.
+bool MatchesClearChannelIdFilter(mojom::ClearDataFilter_Type filter_type,
+                                 std::set<std::string> filter_domains,
+                                 const std::string& channel_id_server_id) {
+  bool found_domain =
+      filter_domains.find(channel_id_server_id) != filter_domains.end();
+  return (filter_type == mojom::ClearDataFilter_Type::DELETE_MATCHES) ==
+         found_domain;
+}
+
 }  // namespace
 
 constexpr bool NetworkContext::enable_resource_scheduler_;
@@ -497,7 +508,7 @@ void NetworkContext::ClearNetworkingHistorySince(
 
 void NetworkContext::ClearHttpCache(base::Time start_time,
                                     base::Time end_time,
-                                    mojom::ClearCacheUrlFilterPtr filter,
+                                    mojom::ClearDataFilterPtr filter,
                                     ClearHttpCacheCallback callback) {
   // It's safe to use Unretained below as the HttpCacheDataRemover is owner by
   // |this| and guarantees it won't call its callback if deleted.
@@ -522,6 +533,32 @@ void NetworkContext::OnHttpCacheCleared(ClearHttpCacheCallback callback,
   std::move(callback).Run();
 }
 
+void NetworkContext::ClearChannelIds(base::Time start_time,
+                                     base::Time end_time,
+                                     mojom::ClearDataFilterPtr filter,
+                                     ClearChannelIdsCallback callback) {
+  base::RepeatingCallback<bool(const std::string& channel_id_server_id)>
+      filter_predicate;
+  if (filter) {
+    DCHECK(filter->origins.empty())
+        << "Origin filtering not allowed in a ClearChannelIds request as "
+           "channel IDs are only keyed by domain.";
+
+    std::set<std::string> filter_domains;
+    filter_domains.insert(filter->domains.begin(), filter->domains.end());
+    filter_predicate = base::BindRepeating(
+        &MatchesClearChannelIdFilter, filter->type, std::move(filter_domains));
+  } else {
+    filter_predicate =
+        base::BindRepeating([](const std::string&) { return true; });
+  }
+
+  url_request_context_->channel_id_service()
+      ->GetChannelIDStore()
+      ->DeleteForDomainsCreatedBetween(std::move(filter_predicate), start_time,
+                                       end_time, std::move(callback));
+}
+
 void NetworkContext::SetNetworkConditions(
     const std::string& profile_id,
     mojom::NetworkConditionsPtr conditions) {

services/network/network_context.h

@@ -117,8 +117,12 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkContext
       base::OnceClosure completion_callback) override;
   void ClearHttpCache(base::Time start_time,
                       base::Time end_time,
-                      mojom::ClearCacheUrlFilterPtr filter,
+                      mojom::ClearDataFilterPtr filter,
                       ClearHttpCacheCallback callback) override;
+  void ClearChannelIds(base::Time start_time,
+                       base::Time end_time,
+                       mojom::ClearDataFilterPtr filter,
+                       ClearChannelIdsCallback callback) override;
   void SetNetworkConditions(const std::string& profile_id,
                             mojom::NetworkConditionsPtr conditions) override;
   void SetAcceptLanguage(const std::string& new_accept_language) override;

services/network/network_context_unittest.cc

@@ -18,6 +18,7 @@
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
+#include "base/test/gtest_util.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/scoped_task_environment.h"
@@ -44,6 +45,8 @@
 #include "net/proxy_resolution/proxy_config.h"
 #include "net/proxy_resolution/proxy_info.h"
 #include "net/proxy_resolution/proxy_resolution_service.h"
+#include "net/ssl/channel_id_service.h"
+#include "net/ssl/channel_id_store.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/http_user_agent_settings.h"
@@ -57,6 +60,7 @@
 #include "services/network/public/mojom/proxy_config.mojom.h"
 #include "services/network/test/test_url_loader_client.h"
 #include "services/network/udp_socket_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/scheme_host_port.h"
@@ -633,7 +637,7 @@ TEST_F(NetworkContextTest, ClearHttpCacheWithNoCache) {
   ASSERT_EQ(nullptr, cache);
   base::RunLoop run_loop;
   network_context->ClearHttpCache(base::Time(), base::Time(),
-                                  /*filter=*/nullptr,
+                                  nullptr /* filter */,
                                   base::BindOnce(run_loop.QuitClosure()));
   run_loop.Run();
 }
@@ -679,7 +683,7 @@ TEST_F(NetworkContextTest, ClearHttpCache) {
   EXPECT_EQ(entry_urls.size(), static_cast<size_t>(backend->GetEntryCount()));
   base::RunLoop run_loop;
   network_context->ClearHttpCache(base::Time(), base::Time(),
-                                  /*filter=*/nullptr,
+                                  nullptr /* filter */,
                                   base::BindOnce(run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_EQ(0U, static_cast<size_t>(backend->GetEntryCount()));
@@ -702,16 +706,176 @@ TEST_F(NetworkContextTest, MultipleClearHttpCacheCalls) {
 
   base::RunLoop run_loop;
   base::RepeatingClosure barrier_closure = base::BarrierClosure(
-      /*num_closures=*/kNumberOfClearCalls, run_loop.QuitClosure());
+      kNumberOfClearCalls /* num_closures */, run_loop.QuitClosure());
   for (int i = 0; i < kNumberOfClearCalls; i++) {
     network_context->ClearHttpCache(base::Time(), base::Time(),
-                                    /*filter=*/nullptr,
+                                    nullptr /* filter */,
                                     base::BindOnce(barrier_closure));
   }
   run_loop.Run();
   // If all the callbacks were invoked, we should terminate.
 }
 
+TEST_F(NetworkContextTest, ClearChannelIds) {
+  std::unique_ptr<NetworkContext> network_context =
+      CreateContextWithParams(CreateContextParams());
+
+  net::ChannelIDStore* store = network_context->url_request_context()
+                                   ->channel_id_service()
+                                   ->GetChannelIDStore();
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "google.com", base::Time::FromDoubleT(123),
+      crypto::ECPrivateKey::Create()));
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "chromium.org", base::Time::FromDoubleT(456),
+      crypto::ECPrivateKey::Create()));
+
+  ASSERT_EQ(2, store->GetChannelIDCount());
+
+  base::RunLoop run_loop;
+  network_context->ClearChannelIds(base::Time(), base::Time(),
+                                   nullptr /* filter */,
+                                   base::BindOnce(run_loop.QuitClosure()));
+  run_loop.Run();
+
+  EXPECT_EQ(0, store->GetChannelIDCount());
+}
+
+TEST_F(NetworkContextTest, ClearEmptyChannelIds) {
+  std::unique_ptr<NetworkContext> network_context =
+      CreateContextWithParams(CreateContextParams());
+
+  net::ChannelIDStore* store = network_context->url_request_context()
+                                   ->channel_id_service()
+                                   ->GetChannelIDStore();
+  ASSERT_EQ(0, store->GetChannelIDCount());
+
+  base::RunLoop run_loop;
+  network_context->ClearChannelIds(base::Time(), base::Time(),
+                                   nullptr /* filter */,
+                                   base::BindOnce(run_loop.QuitClosure()));
+  run_loop.Run();
+
+  EXPECT_EQ(0, store->GetChannelIDCount());
+}
+
+void GetAllChannelIdsCallback(
+    base::RunLoop* run_loop,
+    net::ChannelIDStore::ChannelIDList* dest,
+    const net::ChannelIDStore::ChannelIDList& result) {
+  *dest = result;
+  run_loop->Quit();
+}
+
+TEST_F(NetworkContextTest, ClearChannelIdsWithKeepFilter) {
+  std::unique_ptr<NetworkContext> network_context =
+      CreateContextWithParams(CreateContextParams());
+
+  net::ChannelIDStore* store = network_context->url_request_context()
+                                   ->channel_id_service()
+                                   ->GetChannelIDStore();
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "google.com", base::Time::FromDoubleT(123),
+      crypto::ECPrivateKey::Create()));
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "chromium.org", base::Time::FromDoubleT(456),
+      crypto::ECPrivateKey::Create()));
+
+  ASSERT_EQ(2, store->GetChannelIDCount());
+
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::KEEP_MATCHES;
+  filter->domains.push_back("chromium.org");
+
+  base::RunLoop run_loop1;
+  network_context->ClearChannelIds(base::Time(), base::Time(),
+                                   std::move(filter),
+                                   base::BindOnce(run_loop1.QuitClosure()));
+  run_loop1.Run();
+
+  base::RunLoop run_loop2;
+  net::ChannelIDStore::ChannelIDList channel_ids;
+  store->GetAllChannelIDs(
+      base::BindRepeating(&GetAllChannelIdsCallback, &run_loop2, &channel_ids));
+  run_loop2.Run();
+  ASSERT_EQ(1u, channel_ids.size());
+  EXPECT_EQ("chromium.org", channel_ids.front().server_identifier());
+}
+
+TEST_F(NetworkContextTest, ClearChannelIdsWithDeleteFilter) {
+  std::unique_ptr<NetworkContext> network_context =
+      CreateContextWithParams(CreateContextParams());
+
+  net::ChannelIDStore* store = network_context->url_request_context()
+                                   ->channel_id_service()
+                                   ->GetChannelIDStore();
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "google.com", base::Time::FromDoubleT(123),
+      crypto::ECPrivateKey::Create()));
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "chromium.org", base::Time::FromDoubleT(456),
+      crypto::ECPrivateKey::Create()));
+
+  ASSERT_EQ(2, store->GetChannelIDCount());
+
+  mojom::ClearDataFilterPtr filter = mojom::ClearDataFilter::New();
+  filter->type = mojom::ClearDataFilter_Type::DELETE_MATCHES;
+  filter->domains.push_back("chromium.org");
+
+  base::RunLoop run_loop1;
+  network_context->ClearChannelIds(base::Time(), base::Time(),
+                                   std::move(filter),
+                                   base::BindOnce(run_loop1.QuitClosure()));
+  run_loop1.Run();
+
+  base::RunLoop run_loop2;
+  net::ChannelIDStore::ChannelIDList channel_ids;
+  store->GetAllChannelIDs(
+      base::BindRepeating(&GetAllChannelIdsCallback, &run_loop2, &channel_ids));
+  run_loop2.Run();
+  ASSERT_EQ(1u, channel_ids.size());
+  EXPECT_EQ("google.com", channel_ids.front().server_identifier());
+}
+
+TEST_F(NetworkContextTest, ClearChannelIdsWithTimeRange) {
+  std::unique_ptr<NetworkContext> network_context =
+      CreateContextWithParams(CreateContextParams());
+
+  net::ChannelIDStore* store = network_context->url_request_context()
+                                   ->channel_id_service()
+                                   ->GetChannelIDStore();
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "google.com", base::Time::FromDoubleT(123),
+      crypto::ECPrivateKey::Create()));
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "chromium.org", base::Time::FromDoubleT(456),
+      crypto::ECPrivateKey::Create()));
+  store->SetChannelID(std::make_unique<net::ChannelIDStore::ChannelID>(
+      "gmail.com", base::Time::FromDoubleT(789),
+      crypto::ECPrivateKey::Create()));
+
+  ASSERT_EQ(3, store->GetChannelIDCount());
+
+  base::RunLoop run_loop1;
+  network_context->ClearChannelIds(
+      base::Time::FromDoubleT(450), base::Time::FromDoubleT(460),
+      nullptr /* filter */, base::BindOnce(run_loop1.QuitClosure()));
+  run_loop1.Run();
+
+  base::RunLoop run_loop2;
+  net::ChannelIDStore::ChannelIDList channel_ids;
+  store->GetAllChannelIDs(
+      base::BindRepeating(&GetAllChannelIdsCallback, &run_loop2, &channel_ids));
+  run_loop2.Run();
+
+  std::vector<std::string> identifiers;
+  for (const auto& id : channel_ids) {
+    identifiers.push_back(id.server_identifier());
+  }
+  EXPECT_THAT(identifiers,
+              testing::UnorderedElementsAre("google.com", "gmail.com"));
+}
+
 void SetCookieCallback(base::RunLoop* run_loop, bool* result_out, bool result) {
   *result_out = result;
   run_loop->Quit();

services/network/public/mojom/network_service.mojom

@@ -133,9 +133,9 @@ struct NetworkConditions {
   double upload_throughput;
 };
 
-// Used in NetworkContext.ClearHttpCache() to specify the resources to
-// keep/delete based on their URLs.
-struct ClearCacheUrlFilter {
+// Used in some clearing methods of URL-keyed data to specify the resources to
+// keep/delete.
+struct ClearDataFilter {
   enum Type {DELETE_MATCHES, KEEP_MATCHES};
 
   Type type;
@@ -182,7 +182,18 @@ interface NetworkContext {
   // in either direction by using null Time values for either argument.
   ClearHttpCache(mojo_base.mojom.Time start_time,
                  mojo_base.mojom.Time end_time,
-                 ClearCacheUrlFilter? filter) => ();
+                 ClearDataFilter? filter) => ();
+
+  // Clears channel IDs. A specific range of time can be specified with
+  // |start_time| and |end_time|. This supports unbounded deletes in either
+  // direction by using null Time values for either argument.
+  //
+  // If a non-null |filter| is specified, will clear only IDs matching the
+  // filter. Filtering by origins is not supported. If |filter| is non-null,
+  // |filter.origins| must be empty.
+  ClearChannelIds(mojo_base.mojom.Time start_time,
+                  mojo_base.mojom.Time end_time,
+                  ClearDataFilter? filter) => ();
 
   // Configures network conditions for the specified throttling profile.
   // The throttling will be applied only to requests that have