Reporting: Plumb from //chrome/browser/browsing_data.

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc

 // Copyright 2017 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/chrome_browsing_data_remover_delegate.h"
 
 #include "base/guid.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 45 matching lines @@
 #include "components/password_manager/core/browser/password_manager_test_utils.h"
 #include "components/password_manager/core/browser/password_store_consumer.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/translate/core/browser/language_model.h"
 #include "content/public/browser/browsing_data_filter_builder.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/http_transaction_factory.h"
+#include "net/reporting/reporting_browsing_data_remover.h"
+#include "net/reporting/reporting_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/favicon_size.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/webapps/webapp_registry.h"
 #endif
 
 #if defined(OS_CHROMEOS)
@@ skipping 757 matching lines @@
 
  private:
   void OnPersonalDataChanged() override {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   autofill::PersonalDataManager* personal_data_manager_;
   DISALLOW_COPY_AND_ASSIGN(RemoveAutofillTester);
 };
 
+class MockReportingService : public net::ReportingService {
+ public:
+  MockReportingService() {}
+
+  // net::ReportingService implementation:
+
+  ~MockReportingService() override {}
+
+  void QueueReport(const GURL& url,
+                   const std::string& group,
+                   const std::string& type,
+                   std::unique_ptr<const base::Value> body) override {
+    NOTREACHED();
+  }
+
+  void ProcessHeader(const GURL& url,
+                     const std::string& header_value) override {
+    NOTREACHED();
+  }
+
+  void RemoveBrowsingData(
+      int data_type_mask,
+      base::Callback<bool(const GURL&)> origin_filter) override {
+    ++remove_calls_;
+    last_data_type_mask_ = data_type_mask;
+    last_origin_filter_ = origin_filter;
+  }
+
+  int remove_calls() const { return remove_calls_; }
+  int last_data_type_mask() const { return last_data_type_mask_; }
+  base::Callback<bool(const GURL&)> last_origin_filter() const {
+    return last_origin_filter_;
+  }
+
+ private:
+  int remove_calls_ = 0;
+  int last_data_type_mask_ = 0;
+  base::Callback<bool(const GURL&)> last_origin_filter_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockReportingService);
+};
+
+class ClearReportingCacheTester {
+ public:
+  ClearReportingCacheTester(TestingProfile* profile, bool create_service)
+      : profile_(profile) {
+    if (create_service)
+      service_ = base::MakeUnique<MockReportingService>();
+
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&ClearReportingCacheTester::SetUpOnIOThread,
+                   base::Unretained(this)),
+        run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  void SetUpOnIOThread() {
+    net::URLRequestContext* request_context =
+        profile_->GetRequestContext()->GetURLRequestContext();
+    old_service_ = request_context->reporting_service();
+    request_context->set_reporting_service(service_.get());
+  }
+
+  ~ClearReportingCacheTester() {
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&ClearReportingCacheTester::TearDownOnIOThread,
+                   base::Unretained(this)),
+        run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  void TearDownOnIOThread() {
+    net::URLRequestContext* request_context =
+        profile_->GetRequestContext()->GetURLRequestContext();
+    DCHECK_EQ(service_.get(), request_context->reporting_service());
+    request_context->set_reporting_service(old_service_);
+  }
+
+  void GetMockInfo(int* remove_calls_out,
+                   int* last_data_type_mask_out,
+                   base::Callback<bool(const GURL&)>* last_origin_filter_out) {
+    DCHECK_NE(nullptr, service_.get());
+
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&ClearReportingCacheTester::GetMockInfoOnIOThread,
+                   base::Unretained(this), remove_calls_out,
+                   last_data_type_mask_out, last_origin_filter_out),
+        run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  void GetMockInfoOnIOThread(
+      int* remove_calls_out,
+      int* last_data_type_mask_out,
+      base::Callback<bool(const GURL&)>* last_origin_filter_out) {
+    *remove_calls_out = service_->remove_calls();
+    *last_data_type_mask_out = service_->last_data_type_mask();
+    *last_origin_filter_out = service_->last_origin_filter();
+  }
+
+ private:
+  TestingProfile* profile_;
+  std::unique_ptr<MockReportingService> service_;
+  net::ReportingService* old_service_;
+};
+
 // Test Class -----------------------------------------------------------------
 
 class ChromeBrowsingDataRemoverDelegateTest : public testing::Test {
  public:
   ChromeBrowsingDataRemoverDelegateTest()
       : profile_(new TestingProfile()),
         clear_domain_reliability_tester_(profile_.get()) {
     remover_ = BrowsingDataRemoverFactory::GetForBrowserContext(profile_.get());
 
 #if defined(OS_ANDROID)
@@ skipping 1135 matching lines @@
   EXPECT_FALSE(Match(kOrigin1, kProtected, nullptr));
   EXPECT_FALSE(Match(kOriginExt, kProtected, nullptr));
   EXPECT_FALSE(Match(kOriginDevTools, kProtected, nullptr));
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   EXPECT_FALSE(Match(kOrigin1, kExtension, nullptr));
   EXPECT_TRUE(Match(kOriginExt, kExtension, nullptr));
   EXPECT_FALSE(Match(kOriginDevTools, kExtension, nullptr));
 #endif
 }
+
+TEST_F(ChromeBrowsingDataRemoverDelegateTest, ReportingCache_NoService) {
+  ClearReportingCacheTester tester(GetProfile(), false);
+
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_COOKIES |
+          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(),
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, true);
+
+  int remove_count;
+  int data_type_mask;
+  base::Callback<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(),
+                              BrowsingDataRemover::DATA_TYPE_COOKIES,
+                              builder->Copy());
+
+  int remove_count;
+  int data_type_mask;
+  base::Callback<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) {
+  ClearReportingCacheTester tester(GetProfile(), true);
+
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, true);
+
+  int remove_count;
+  int data_type_mask;
+  base::Callback<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,
+            data_type_mask);
+  EXPECT_TRUE(ProbablySameFilters(BrowsingDataFilterBuilder::BuildNoopFilter(),
+                                  origin_filter));
+}
+
+// Disabled because history is not iterable yet.
+TEST_F(ChromeBrowsingDataRemoverDelegateTest,
+       DISABLED_ReportingCache_History_WithFilter) {
+  ClearReportingCacheTester tester(GetProfile(), true);
+
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  builder->AddRegisterableDomain(kTestRegisterableDomain1);
+
+  BlockUntilOriginDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, builder->Copy());
+
+  int remove_count;
+  int data_type_mask;
+  base::Callback<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,
+            data_type_mask);
+  EXPECT_TRUE(
+      ProbablySameFilters(builder->BuildGeneralFilter(), origin_filter));
+}
+
+TEST_F(ChromeBrowsingDataRemoverDelegateTest,
+       ReportingCache_CookiesAndHistory) {
+  ClearReportingCacheTester tester(GetProfile(), true);
+
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_COOKIES |
+          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+      true);
+
+  int remove_count;
+  int data_type_mask;
+  base::Callback<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));
+}
+
+// Disabled because history is not iterable yet.

[shivanisha, 2017/04/20 18:21:52]

Is iterable history something that is being worked on? Can a crbug/todo
reference be included here?

[Julia Tuttle, 2017/04/21 13:34:53]

I have no idea -- I just know that the similar Domain Reliability test is also
disabled, and that this test fails a CHECK if I enable it.

I'm assuming whoever fixes it will re-enable all the relevant tests.

+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(),
+      BrowsingDataRemover::DATA_TYPE_COOKIES |
+          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+      builder->Copy());
+
+  int remove_count;
+  int data_type_mask;
+  base::Callback<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));
+}