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 {
+    DCHECK(origin_filter_builder_ || domain_filter_builder_);
+    DCHECK(!origin_filter_builder_ || !domain_filter_builder_);
+
+    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 |
+                               BrowsingDataRemover::REMOVE_CHANNEL_IDS},
+      {false, true, false, BrowsingDataRemover::REMOVE_SITE_DATA &
+                               ~BrowsingDataRemover::REMOVE_COOKIES &
+                               ~BrowsingDataRemover::REMOVE_CHANNEL_IDS},
+      {false, false, true, BrowsingDataRemover::REMOVE_CACHE},
+      {true, true, false, BrowsingDataRemover::REMOVE_SITE_DATA},
+      {true, false, true, BrowsingDataRemover::REMOVE_COOKIES |
+                              BrowsingDataRemover::REMOVE_CHANNEL_IDS |
+                              BrowsingDataRemover::REMOVE_CACHE},
+      {false, true, true, BrowsingDataRemover::REMOVE_CACHE |
+                              (BrowsingDataRemover::REMOVE_SITE_DATA &
+                               ~BrowsingDataRemover::REMOVE_COOKIES &
+                               ~BrowsingDataRemover::REMOVE_CHANNEL_IDS)},
+      {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 |
+                                        BrowsingDataRemover::REMOVE_CHANNEL_IDS,
+                                 _, 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