Servicify browser data calls to clear reporting information.

Also servicified ClearNetworkErrorLogging as it's extremely similar
logic.

Moved the clearing on DATA_TYPE_COOKIES to BrowsingDataRemoverImpl as it
is not chrome-specific, and left the clearing on DATA_TYPE_HISTORY in
ChromeBrowsingDataRemoverDelegate. Especially good cleanup for Reporting
data as the two cases were split into two independent Clear... methods
in NetworkContext.

Bug: 824997
Change-Id: Ie13ef2277d9040f73e87b77be49ba47305462aab
Reviewed-on: https://chromium-review.googlesource.com/1045206
Commit-Queue: Eric Orth <ericorth@chromium.org>
Reviewed-by: Martin Šrámek <msramek@chromium.org>
Reviewed-by: Helen Li <xunjieli@chromium.org>
Cr-Commit-Position: refs/heads/master@{#559172}

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.cc

@@ -149,6 +149,8 @@ using content::BrowsingDataFilterBuilder;
 
 namespace {
 
+// Generic functions but currently only used when ENABLE_NACL.
+#if BUILDFLAG(ENABLE_NACL)
 void UIThreadTrampolineHelper(base::OnceClosure callback) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, std::move(callback));
 }
@@ -161,6 +163,7 @@ base::OnceClosure UIThreadTrampoline(base::OnceClosure callback) {
   // task is actually posted.
   return base::BindOnce(&UIThreadTrampolineHelper, std::move(callback));
 }
+#endif  // BUILDFLAG(ENABLE_NACL)
 
 template <typename T>
 void IgnoreArgumentHelper(base::OnceClosure callback, T unused_argument) {
@@ -224,31 +227,6 @@ void ClearHostnameResolutionCacheOnIOThread(
   io_thread->ClearHostCache(host_filter);
 }
 
-#if BUILDFLAG(ENABLE_REPORTING)
-void ClearReportingCacheOnIOThread(
-    net::URLRequestContextGetter* context,
-    int data_type_mask,
-    const base::RepeatingCallback<bool(const GURL&)>& origin_filter) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  net::ReportingService* service =
-      context->GetURLRequestContext()->reporting_service();
-  if (service)
-    service->RemoveBrowsingData(data_type_mask, origin_filter);
-}
-
-void ClearNetworkErrorLoggingOnIOThread(
-    net::URLRequestContextGetter* context,
-    const base::RepeatingCallback<bool(const GURL&)>& origin_filter) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  net::NetworkErrorLoggingService* service =
-      context->GetURLRequestContext()->network_error_logging_service();
-  if (service)
-    service->RemoveBrowsingData(origin_filter);
-}
-#endif  // BUILDFLAG(ENABLE_REPORTING)
-
 #if defined(OS_ANDROID)
 void ClearPrecacheInBackground(content::BrowserContext* browser_context) {
   // Precache code was removed in M61 but the sqlite database file could be
@@ -1081,35 +1059,16 @@ void ChromeBrowsingDataRemoverDelegate::RemoveEmbedderData(
   }
 
 #if BUILDFLAG(ENABLE_REPORTING)
-  if ((remove_mask & content::BrowsingDataRemover::DATA_TYPE_COOKIES) ||
-      (remove_mask & DATA_TYPE_HISTORY)) {
-    scoped_refptr<net::URLRequestContextGetter> context =
-        profile_->GetRequestContext();
-
-    int data_type_mask = 0;
-    if (remove_mask & DATA_TYPE_HISTORY)
-      data_type_mask |= net::ReportingBrowsingDataRemover::DATA_TYPE_REPORTS;
-    if (remove_mask & content::BrowsingDataRemover::DATA_TYPE_COOKIES)
-      data_type_mask |= net::ReportingBrowsingDataRemover::DATA_TYPE_CLIENTS;
-
-    BrowserThread::PostTaskAndReply(
-        BrowserThread::IO, FROM_HERE,
-        base::BindOnce(&ClearReportingCacheOnIOThread,
-                       base::RetainedRef(std::move(context)), data_type_mask,
-                       filter),
-        UIThreadTrampoline(CreatePendingTaskCompletionClosure()));
-  }
-
-  if ((remove_mask & content::BrowsingDataRemover::DATA_TYPE_COOKIES) ||
-      (remove_mask & DATA_TYPE_HISTORY)) {
-    scoped_refptr<net::URLRequestContextGetter> context =
-        profile_->GetRequestContext();
-
-    BrowserThread::PostTaskAndReply(
-        BrowserThread::IO, FROM_HERE,
-        base::BindOnce(&ClearNetworkErrorLoggingOnIOThread,
-                       base::RetainedRef(std::move(context)), filter),
-        UIThreadTrampoline(CreatePendingTaskCompletionClosure()));
+  if (remove_mask & DATA_TYPE_HISTORY) {
+    network::mojom::NetworkContext* network_context =
+        BrowserContext::GetDefaultStoragePartition(profile_)
+            ->GetNetworkContext();
+    network_context->ClearReportingCacheReports(
+        filter_builder.BuildNetworkServiceFilter(),
+        CreatePendingTaskCompletionClosureForMojo());
+    network_context->ClearNetworkErrorLogging(
+        filter_builder.BuildNetworkServiceFilter(),
+        CreatePendingTaskCompletionClosureForMojo());
   }
 #endif  // BUILDFLAG(ENABLE_REPORTING)
 

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc

@@ -2759,58 +2759,13 @@ TEST_F(ChromeBrowsingDataRemoverDelegateTest, ReportingCache_NoService) {
 
   BlockUntilBrowsingDataRemoved(
       base::Time(), base::Time::Max(),
-      content::BrowsingDataRemover::DATA_TYPE_COOKIES |
-          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
-      true);
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, true);
 
   // Nothing to check, since there's no mock service; we're just making sure
   // nothing crashes without a service.
 }
 
-TEST_F(ChromeBrowsingDataRemoverDelegateTest, ReportingCache_Cookies) {
-  ClearReportingCacheTester tester(GetProfile(), true);
-
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                content::BrowsingDataRemover::DATA_TYPE_COOKIES,
-                                true);
-
-  int remove_count;
-  int data_type_mask;
-  base::RepeatingCallback<bool(const GURL&)> origin_filter;
-  tester.GetMockInfo(&remove_count, &data_type_mask, &origin_filter);
-
-  EXPECT_EQ(1, remove_count);
-  EXPECT_EQ(net::ReportingBrowsingDataRemover::DATA_TYPE_CLIENTS,
-            data_type_mask);
-  EXPECT_TRUE(ProbablySameFilters(BrowsingDataFilterBuilder::BuildNoopFilter(),
-                                  origin_filter));
-}
-
-TEST_F(ChromeBrowsingDataRemoverDelegateTest,
-       ReportingCache_Cookies_WithFilter) {
-  ClearReportingCacheTester tester(GetProfile(), true);
-
-  std::unique_ptr<BrowsingDataFilterBuilder> builder(
-      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
-  builder->AddRegisterableDomain(kTestRegisterableDomain1);
-
-  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              content::BrowsingDataRemover::DATA_TYPE_COOKIES,
-                              builder->Copy());
-
-  int remove_count;
-  int data_type_mask;
-  base::RepeatingCallback<bool(const GURL&)> origin_filter;
-  tester.GetMockInfo(&remove_count, &data_type_mask, &origin_filter);
-
-  EXPECT_EQ(1, remove_count);
-  EXPECT_EQ(net::ReportingBrowsingDataRemover::DATA_TYPE_CLIENTS,
-            data_type_mask);
-  EXPECT_TRUE(
-      ProbablySameFilters(builder->BuildGeneralFilter(), origin_filter));
-}
-
-TEST_F(ChromeBrowsingDataRemoverDelegateTest, ReportingCache_History) {
+TEST_F(ChromeBrowsingDataRemoverDelegateTest, ReportingCache) {
   ClearReportingCacheTester tester(GetProfile(), true);
 
   BlockUntilBrowsingDataRemoved(
@@ -2832,7 +2787,7 @@ TEST_F(ChromeBrowsingDataRemoverDelegateTest, ReportingCache_History) {
 // TODO(crbug.com/589586): Disabled, since history is not yet marked as
 // a filterable datatype.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
-       DISABLED_ReportingCache_History_WithFilter) {
+       DISABLED_ReportingCache_WithFilter) {
   ClearReportingCacheTester tester(GetProfile(), true);
 
   std::unique_ptr<BrowsingDataFilterBuilder> builder(
@@ -2855,91 +2810,17 @@ TEST_F(ChromeBrowsingDataRemoverDelegateTest,
       ProbablySameFilters(builder->BuildGeneralFilter(), origin_filter));
 }
 
-TEST_F(ChromeBrowsingDataRemoverDelegateTest,
-       ReportingCache_CookiesAndHistory) {
-  ClearReportingCacheTester tester(GetProfile(), true);
-
-  BlockUntilBrowsingDataRemoved(
-      base::Time(), base::Time::Max(),
-      content::BrowsingDataRemover::DATA_TYPE_COOKIES |
-          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
-      true);
-
-  int remove_count;
-  int data_type_mask;
-  base::RepeatingCallback<bool(const GURL&)> origin_filter;
-  tester.GetMockInfo(&remove_count, &data_type_mask, &origin_filter);
-
-  EXPECT_EQ(1, remove_count);
-  EXPECT_EQ(net::ReportingBrowsingDataRemover::DATA_TYPE_REPORTS |
-                net::ReportingBrowsingDataRemover::DATA_TYPE_CLIENTS,
-            data_type_mask);
-  EXPECT_TRUE(ProbablySameFilters(BrowsingDataFilterBuilder::BuildNoopFilter(),
-                                  origin_filter));
-}
-
-// TODO(crbug.com/589586): Disabled, since history is not yet marked as
-// a filterable datatype.
-TEST_F(ChromeBrowsingDataRemoverDelegateTest,
-       DISABLED_ReportingCache_CookiesAndHistory_WithFilter) {
-  ClearReportingCacheTester tester(GetProfile(), true);
-
-  std::unique_ptr<BrowsingDataFilterBuilder> builder(
-      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
-  builder->AddRegisterableDomain(kTestRegisterableDomain1);
-
-  BlockUntilOriginDataRemoved(
-      base::Time(), base::Time::Max(),
-      content::BrowsingDataRemover::DATA_TYPE_COOKIES |
-          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
-      builder->Copy());
-
-  int remove_count;
-  int data_type_mask;
-  base::RepeatingCallback<bool(const GURL&)> origin_filter;
-  tester.GetMockInfo(&remove_count, &data_type_mask, &origin_filter);
-
-  EXPECT_EQ(1, remove_count);
-  EXPECT_EQ(net::ReportingBrowsingDataRemover::DATA_TYPE_REPORTS |
-                net::ReportingBrowsingDataRemover::DATA_TYPE_CLIENTS,
-            data_type_mask);
-  EXPECT_TRUE(
-      ProbablySameFilters(builder->BuildGeneralFilter(), origin_filter));
-}
-
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, NetworkErrorLogging_NoDelegate) {
   ClearNetworkErrorLoggingTester tester(GetProfile(), false);
 
   BlockUntilBrowsingDataRemoved(
       base::Time(), base::Time::Max(),
-      content::BrowsingDataRemover::DATA_TYPE_COOKIES |
-          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
-      true);
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, true);
 
   // Nothing to check, since there's no mock service; we're just making sure
   // nothing crashes without a service.
 }
 
-TEST_F(ChromeBrowsingDataRemoverDelegateTest, NetworkErrorLogging_Cookies) {
-  ClearNetworkErrorLoggingTester tester(GetProfile(), true);
-
-  std::unique_ptr<BrowsingDataFilterBuilder> builder(
-      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
-  builder->AddRegisterableDomain(kTestRegisterableDomain1);
-
-  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              content::BrowsingDataRemover::DATA_TYPE_COOKIES,
-                              builder->Copy());
-
-  int remove_count;
-  base::RepeatingCallback<bool(const GURL&)> origin_filter;
-  tester.GetMockInfo(&remove_count, &origin_filter);
-
-  EXPECT_EQ(1, remove_count);
-  EXPECT_TRUE(
-      ProbablySameFilters(builder->BuildGeneralFilter(), origin_filter));
-}
-
 // This would use an origin filter, but history isn't yet filterable.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, NetworkErrorLogging_History) {
   ClearNetworkErrorLoggingTester tester(GetProfile(), true);

content/browser/browsing_data/browsing_data_remover_impl.cc

@@ -451,6 +451,22 @@ void BrowsingDataRemoverImpl::RemoveImpl(
         StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
   }
 
+#if BUILDFLAG(ENABLE_REPORTING)
+  //////////////////////////////////////////////////////////////////////////////
+  // Reporting cache.
+  if (remove_mask & DATA_TYPE_COOKIES) {
+    network::mojom::NetworkContext* network_context =
+        BrowserContext::GetDefaultStoragePartition(browser_context_)
+            ->GetNetworkContext();
+    network_context->ClearReportingCacheClients(
+        filter_builder.BuildNetworkServiceFilter(),
+        CreatePendingTaskCompletionClosureForMojo());
+    network_context->ClearNetworkErrorLogging(
+        filter_builder.BuildNetworkServiceFilter(),
+        CreatePendingTaskCompletionClosureForMojo());
+  }
+#endif  // BUILDFLAG(ENABLE_REPORTING)
+
   //////////////////////////////////////////////////////////////////////////////
   // Auth cache.
   if ((remove_mask & DATA_TYPE_COOKIES) &&

content/browser/browsing_data/browsing_data_remover_impl_unittest.cc

@@ -58,19 +58,29 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/origin.h"
 
-using testing::_;
+#if BUILDFLAG(ENABLE_REPORTING)
+#include "net/network_error_logging/network_error_logging_delegate.h"
+#include "net/network_error_logging/network_error_logging_service.h"
+#include "net/reporting/reporting_cache.h"
+#include "net/reporting/reporting_report.h"
+#include "net/reporting/reporting_service.h"
+#include "net/reporting/reporting_test_util.h"
+#endif  // BUILDFLAG(ENABLE_REPORTING)
+
 using testing::ByRef;
 using testing::Eq;
 using testing::Invoke;
 using testing::IsEmpty;
-using testing::Matcher;
 using testing::MakeMatcher;
-using testing::MatcherInterface;
 using testing::MatchResultListener;
+using testing::Matcher;
+using testing::MatcherInterface;
 using testing::Not;
 using testing::Return;
 using testing::SizeIs;
+using testing::UnorderedElementsAre;
 using testing::WithArgs;
+using testing::_;
 using CookieDeletionFilterPtr = network::mojom::CookieDeletionFilterPtr;
 
 namespace content {
@@ -1380,6 +1390,169 @@ TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByOrigin) {
                               std::move(builder));
 }
 
+#if BUILDFLAG(ENABLE_REPORTING)
+TEST_F(BrowsingDataRemoverImplTest, RemoveReportingCache) {
+  auto reporting_context = std::make_unique<net::TestReportingContext>(
+      base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
+      net::ReportingPolicy());
+  net::ReportingCache* reporting_cache = reporting_context->cache();
+  std::unique_ptr<net::ReportingService> reporting_service =
+      net::ReportingService::CreateForTesting(std::move(reporting_context));
+
+  BrowserContext::GetDefaultStoragePartition(GetBrowserContext())
+      ->GetURLRequestContext()
+      ->GetURLRequestContext()
+      ->set_reporting_service(reporting_service.get());
+
+  GURL domain("https://google.com");
+  reporting_cache->SetClient(url::Origin::Create(domain), domain,
+                             net::ReportingClient::Subdomains::EXCLUDE, "group",
+                             base::TimeTicks::Max(), 0, 1);
+
+  std::vector<const net::ReportingClient*> clients;
+  reporting_cache->GetClients(&clients);
+  ASSERT_EQ(1u, clients.size());
+
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
+
+  reporting_cache->GetClients(&clients);
+  EXPECT_TRUE(clients.empty());
+}
+
+TEST_F(BrowsingDataRemoverImplTest, RemoveReportingCache_SpecificOrigins) {
+  auto reporting_context = std::make_unique<net::TestReportingContext>(
+      base::DefaultClock::GetInstance(), base::DefaultTickClock::GetInstance(),
+      net::ReportingPolicy());
+  net::ReportingCache* reporting_cache = reporting_context->cache();
+  std::unique_ptr<net::ReportingService> reporting_service =
+      net::ReportingService::CreateForTesting(std::move(reporting_context));
+
+  BrowserContext::GetDefaultStoragePartition(GetBrowserContext())
+      ->GetURLRequestContext()
+      ->GetURLRequestContext()
+      ->set_reporting_service(reporting_service.get());
+
+  GURL domain1("https://google.com");
+  reporting_cache->SetClient(url::Origin::Create(domain1), domain1,
+                             net::ReportingClient::Subdomains::EXCLUDE, "group",
+                             base::TimeTicks::Max(), 0, 1);
+  GURL domain2("https://host2.com");
+  reporting_cache->SetClient(url::Origin::Create(domain2), domain2,
+                             net::ReportingClient::Subdomains::EXCLUDE, "group",
+                             base::TimeTicks::Max(), 0, 1);
+  GURL domain3("https://host3.com");
+  reporting_cache->SetClient(url::Origin::Create(domain3), domain3,
+                             net::ReportingClient::Subdomains::EXCLUDE, "group",
+                             base::TimeTicks::Max(), 0, 1);
+  GURL domain4("https://host4.com");
+  reporting_cache->SetClient(url::Origin::Create(domain4), domain4,
+                             net::ReportingClient::Subdomains::EXCLUDE, "group",
+                             base::TimeTicks::Max(), 0, 1);
+
+  std::vector<const net::ReportingClient*> clients;
+  reporting_cache->GetClients(&clients);
+  ASSERT_EQ(4u, clients.size());
+
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  filter_builder->AddRegisterableDomain("google.com");
+  filter_builder->AddRegisterableDomain("host3.com");
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
+                              BrowsingDataRemover::DATA_TYPE_COOKIES,
+                              std::move(filter_builder));
+
+  reporting_cache->GetClients(&clients);
+  EXPECT_EQ(2u, clients.size());
+  std::vector<GURL> origins;
+  for (const net::ReportingClient* client : clients) {
+    origins.push_back(client->endpoint);
+  }
+  EXPECT_THAT(origins, UnorderedElementsAre(domain2, domain4));
+}
+
+TEST_F(BrowsingDataRemoverImplTest, RemoveReportingCache_NoService) {
+  ASSERT_FALSE(BrowserContext::GetDefaultStoragePartition(GetBrowserContext())
+                   ->GetURLRequestContext()
+                   ->GetURLRequestContext()
+                   ->reporting_service());
+
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
+}
+
+TEST_F(BrowsingDataRemoverImplTest, RemoveNetworkErrorLogging) {
+  std::unique_ptr<net::NetworkErrorLoggingService> logging_service =
+      net::NetworkErrorLoggingService::Create(
+          net::NetworkErrorLoggingDelegate::Create());
+  BrowserContext::GetDefaultStoragePartition(GetBrowserContext())
+      ->GetURLRequestContext()
+      ->GetURLRequestContext()
+      ->set_network_error_logging_service(logging_service.get());
+
+  GURL domain("https://google.com");
+  logging_service->OnHeader(url::Origin::Create(domain),
+                            "{\"report-to\":\"group\",\"max-age\":86400}");
+
+  ASSERT_EQ(1u, logging_service->GetPolicyOriginsForTesting().size());
+
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
+
+  EXPECT_TRUE(logging_service->GetPolicyOriginsForTesting().empty());
+}
+
+TEST_F(BrowsingDataRemoverImplTest, RemoveNetworkErrorLogging_SpecificOrigins) {
+  std::unique_ptr<net::NetworkErrorLoggingService> logging_service =
+      net::NetworkErrorLoggingService::Create(
+          net::NetworkErrorLoggingDelegate::Create());
+  BrowserContext::GetDefaultStoragePartition(GetBrowserContext())
+      ->GetURLRequestContext()
+      ->GetURLRequestContext()
+      ->set_network_error_logging_service(logging_service.get());
+
+  GURL domain1("https://google.com");
+  logging_service->OnHeader(url::Origin::Create(domain1),
+                            "{\"report-to\":\"group\",\"max-age\":86400}");
+  GURL domain2("https://host2.com");
+  logging_service->OnHeader(url::Origin::Create(domain2),
+                            "{\"report-to\":\"group\",\"max-age\":86400}");
+  GURL domain3("https://host3.com");
+  logging_service->OnHeader(url::Origin::Create(domain3),
+                            "{\"report-to\":\"group\",\"max-age\":86400}");
+  GURL domain4("https://host4.com");
+  logging_service->OnHeader(url::Origin::Create(domain4),
+                            "{\"report-to\":\"group\",\"max-age\":86400}");
+
+  ASSERT_EQ(4u, logging_service->GetPolicyOriginsForTesting().size());
+
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  filter_builder->AddRegisterableDomain("google.com");
+  filter_builder->AddRegisterableDomain("host3.com");
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
+                              BrowsingDataRemover::DATA_TYPE_COOKIES,
+                              std::move(filter_builder));
+
+  std::set<url::Origin> policy_origins =
+      logging_service->GetPolicyOriginsForTesting();
+  EXPECT_EQ(2u, policy_origins.size());
+  EXPECT_THAT(policy_origins,
+              UnorderedElementsAre(url::Origin::Create(domain2),
+                                   url::Origin::Create(domain4)));
+}
+
+TEST_F(BrowsingDataRemoverImplTest, RemoveNetworkErrorLogging_NoService) {
+  ASSERT_FALSE(BrowserContext::GetDefaultStoragePartition(GetBrowserContext())
+                   ->GetURLRequestContext()
+                   ->GetURLRequestContext()
+                   ->network_error_logging_service());
+
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
+}
+#endif  // BUILDFLAG(ENABLE_REPORTING)
+
 class MultipleTasksObserver {
  public:
   // A simple implementation of BrowsingDataRemover::Observer.