First experimental implementation of the Clear-Site-Data header

chrome/browser/chrome_content_browser_client_unittest.cc

 // Copyright 2013 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/chrome_content_browser_client.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "chrome/browser/browsing_data/browsing_data_filter_builder.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/origin_filter_builder.h"
+#include "chrome/browser/browsing_data/registrable_domain_filter_builder.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
+#include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_associated_data.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 #if !defined(OS_ANDROID)
 #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/browser_with_test_window_test.h"
 #include "chrome/test/base/search_test_utils.h"
 #endif
 
+using testing::_;
 using ChromeContentBrowserClientTest = testing::Test;
 
 TEST_F(ChromeContentBrowserClientTest, ShouldAssignSiteForURL) {
   ChromeContentBrowserClient client;
   EXPECT_FALSE(client.ShouldAssignSiteForURL(GURL("chrome-native://test")));
   EXPECT_TRUE(client.ShouldAssignSiteForURL(GURL("http://www.google.com")));
   EXPECT_TRUE(client.ShouldAssignSiteForURL(GURL("https://www.google.com")));
 }
 
 // BrowserWithTestWindowTest doesn't work on Android.
@@ skipping 275 matching lines @@
 
   NavigationEntry* entry = browser()->tab_strip_model()->
       GetActiveWebContents()->GetController().GetLastCommittedEntry();
   ASSERT_TRUE(entry != NULL);
   EXPECT_EQ(url_rewritten, entry->GetURL());
   EXPECT_EQ(url_original, entry->GetVirtualURL());
 }
 
 }  // namespace content
 #endif  // !defined(OS_ANDROID)
+
+namespace {
+
+// Tests for ChromeContentBrowserClient::ClearSiteData().
+class ChromeContentBrowserClientClearSiteDataTest : public testing::Test {
+ public:
+  class MockBrowsingDataRemover : public BrowsingDataRemover {
+   public:
+    explicit MockBrowsingDataRemover(content::BrowserContext* context)
+        : BrowsingDataRemover(context) {}
+    ~MockBrowsingDataRemover() {}
+
+    MOCK_METHOD4(RemoveWithFilter, void(
+        const TimeRange& time_range, int remove_mask, int origin_type_mask,
+        const BrowsingDataFilterBuilder& filter_builder));
+  };
+
+  void SetUp() override {
+    BrowsingDataRemoverFactory::GetInstance()->SetTestingFactoryAndUse(
+        &profile_, &ChromeContentBrowserClientClearSiteDataTest::GetRemover);
+  }
+
+  content::BrowserContext* profile() {
+    return &profile_;
+  }
+
+  MockBrowsingDataRemover* remover() {
+    return static_cast<MockBrowsingDataRemover*>(
+        BrowsingDataRemoverFactory::GetForBrowserContext(&profile_));
+  }
+
+ private:
+  static std::unique_ptr<KeyedService> GetRemover(
+      content::BrowserContext* context) {
+    return base::WrapUnique(new MockBrowsingDataRemover(context));
+  }
+
+  base::MessageLoop loop_;
+  TestingProfile profile_;
+};
+
+// Matcher for BrowsingDataFilterBuilder. As it is not possible to compare
+// two BrowsingDataFilterBuilder-s of different kinds, it can only be used
+// when we know which subclass of BrowsingDataFilterBuilder we expect:
+// OriginFilterBuilder or RegistrableDomainFilterBuilder.
+class SameBuilderMatcher :
+    public testing::MatcherInterface<const BrowsingDataFilterBuilder&> {
+ public:
+  explicit SameBuilderMatcher(const OriginFilterBuilder& builder)
+      : origin_filter_builder_(&builder), domain_filter_builder_(nullptr) {
+  }
+
+  explicit SameBuilderMatcher(const RegistrableDomainFilterBuilder& builder)
+      : origin_filter_builder_(nullptr), domain_filter_builder_(&builder) {
+  }
+
+  virtual bool MatchAndExplain(const BrowsingDataFilterBuilder& builder,
+                               testing::MatchResultListener* listener) const {
+    if (origin_filter_builder_) {
+      return *origin_filter_builder_ ==
+          static_cast<const OriginFilterBuilder&>(builder);
+    }
+
+    if (domain_filter_builder_) {
+      return *domain_filter_builder_ ==
+          static_cast<const RegistrableDomainFilterBuilder&>(builder);
+    }
+
+    NOTREACHED();
+    return false;
+  }
+
+  void DescribeTo(std::ostream* os) const override {
+    *os << "has the same scope, mode, and added entries as the expected "
+        << "filter builder.";
+  }
+
+  void DescribeNegationTo(std::ostream* os) const override {
+    *os << "differs from the expected filter builder in scope, mode, "
+        << "or added entries.";
+  }
+
+ private:
+  const OriginFilterBuilder* origin_filter_builder_;
+  const RegistrableDomainFilterBuilder* domain_filter_builder_;
+};
+
+// Tests that the parameters to ClearBrowsingData() are translated to
+// the correct BrowsingDataRemover::RemoveWithFilter() operation. The fourth
+// parameter, |filter_builder|, is tested in detail in the RegistrableDomains
+// test below.
+TEST_F(ChromeContentBrowserClientClearSiteDataTest, Parameters) {
+  ChromeContentBrowserClient client;
+
+  struct TestCase {
+    bool cookies;
+    bool storage;
+    bool cache;
+    int mask;
+  } test_cases[] = {
+      { false, false, false, 0 },
+      { true, false, false, BrowsingDataRemover::REMOVE_COOKIES },
+      { false, true, false,
+          BrowsingDataRemover::REMOVE_SITE_DATA &
+              ~BrowsingDataRemover::REMOVE_COOKIES },
+      { false, false, true, BrowsingDataRemover::REMOVE_CACHE },
+      { true, true, false, BrowsingDataRemover::REMOVE_SITE_DATA },
+      { true, false, true,
+            BrowsingDataRemover::REMOVE_COOKIES |
+                BrowsingDataRemover::REMOVE_CACHE },
+      { false, true, true,
+            BrowsingDataRemover::REMOVE_CACHE |
+                (BrowsingDataRemover::REMOVE_SITE_DATA &
+                    ~BrowsingDataRemover::REMOVE_COOKIES) },
+      { true, true, true,
+        BrowsingDataRemover::REMOVE_SITE_DATA |
+            BrowsingDataRemover::REMOVE_CACHE },
+  };
+
+  for (const TestCase& test_case : test_cases) {
+    SCOPED_TRACE(test_case.mask);
+
+    // We always delete data for all time and all origin types.
+    BrowsingDataRemover::TimeRange all_time(base::Time(), base::Time::Max());
+    BrowsingDataHelper::OriginTypeMask all_origin_types =
+        BrowsingDataHelper::ALL;
+
+    // Some data are deleted for the origin and some for the registrable domain.
+    // Depending on the chosen datatypes, this might result into one or two
+    // calls. In the latter case, the removal mask will be split into two
+    // parts - one for the origin deletion and one for the registrable domain.
+    const int domain_scoped_types =
+        BrowsingDataRemover::REMOVE_COOKIES &
+        BrowsingDataRemover::REMOVE_CHANNEL_IDS;
+    int origin_deletion_mask =
+        test_case.mask & domain_scoped_types;
+    int registrable_domain_deletion_mask =
+        test_case.mask & ~domain_scoped_types;
+
+    EXPECT_CALL(
+        *remover(),
+        RemoveWithFilter(
+            all_time,
+            origin_deletion_mask,
+            all_origin_types,
+            _)).Times(origin_deletion_mask != 0);
+
+    EXPECT_CALL(
+        *remover(),
+        RemoveWithFilter(
+            all_time,
+            registrable_domain_deletion_mask,
+            all_origin_types,
+            _)).Times(registrable_domain_deletion_mask != 0);
+
+    client.ClearSiteData(
+        profile(), url::Origin(GURL("https://www.example.com")),
+        test_case.cookies, test_case.storage, test_case.cache);
+
+    testing::Mock::VerifyAndClearExpectations(remover());
+  }
+}
+
+// Tests that ClearBrowsingData() called for an origin deletes cookies in the
+// scope of the registrable domain corresponding to that origin, while cache
+// is deleted for that exact origin.
+TEST_F(ChromeContentBrowserClientClearSiteDataTest, RegistrableDomains) {
+  ChromeContentBrowserClient client;
+
+  struct TestCase {
+      const char* origin;  // origin on which ClearSiteData() is called.
+      const char* domain;  // domain on which cookies will be deleted.
+  } test_cases[] = {
+      // TLD has no embedded dot.
+      { "https://example.com", "example.com" },
+      { "https://www.example.com", "example.com" },
+      { "https://www.fourth.third.second.com", "second.com" },
+
+      // TLD has one embedded dot.
+      { "https://www.example.co.uk", "example.co.uk" },
+      { "https://example.co.uk", "example.co.uk" },
+
+      // TLD has more embedded dots.
+      { "https://www.website.sp.nom.br", "website.sp.nom.br" },
+
+      // IP addresses.
+      { "http://127.0.0.1", "127.0.0.1" },
+      { "http://192.168.0.1", "192.168.0.1" },
+      { "http://192.168.0.1", "192.168.0.1" },
+
+      // Internal hostnames.
+      { "http://localhost", "localhost" },
+      { "http://fileserver", "fileserver" },
+
+      // These are not subdomains of internal hostnames, but subdomain of
+      // unknown TLDs.
+      { "http://subdomain.localhost", "subdomain.localhost" },
+      { "http://www.subdomain.localhost", "subdomain.localhost" },
+      { "http://documents.fileserver", "documents.fileserver" },
+
+      // Scheme and port don't matter.
+      { "http://example.com", "example.com" },
+      { "http://example.com:8080", "example.com" },
+      { "https://example.com:4433", "example.com" },
+  };
+
+  for (const TestCase& test_case : test_cases) {
+    SCOPED_TRACE(test_case.origin);
+
+    OriginFilterBuilder origin_filter_builder(
+        BrowsingDataFilterBuilder::WHITELIST);
+    origin_filter_builder.AddOrigin(url::Origin(GURL(test_case.origin)));
+
+    EXPECT_CALL(
+        *remover(),
+        RemoveWithFilter(
+            _,
+            BrowsingDataRemover::REMOVE_CACHE,
+            _,
+            MakeMatcher(new SameBuilderMatcher(
+                origin_filter_builder))));
+
+    RegistrableDomainFilterBuilder registrable_domain_filter_builder(
+        BrowsingDataFilterBuilder::WHITELIST);
+    registrable_domain_filter_builder.AddRegisterableDomain(test_case.domain);
+
+    EXPECT_CALL(*remover(),
+                RemoveWithFilter(
+                    _,
+                    BrowsingDataRemover::REMOVE_COOKIES,
+                    _,
+                    MakeMatcher(new SameBuilderMatcher(
+                        registrable_domain_filter_builder))));
+
+    client.ClearSiteData(
+        profile(), url::Origin(GURL(test_case.origin)),
+        true /* cookies */, false /* storage */, true /* cache */);
+
+    testing::Mock::VerifyAndClearExpectations(remover());
+  }
+}
+
+}  // namespace