Domain Reliability: Default to enabled

chrome/browser/browsing_data/browsing_data_remover_unittest.cc

 // Copyright (c) 2012 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/browsing_data_remover.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 649 matching lines @@
 }
 
 class ClearDomainReliabilityTester {
  public:
   explicit ClearDomainReliabilityTester(TestingProfile* profile) :
       profile_(profile),
       mock_service_(new MockDomainReliabilityService()) {
     AttachService();
   }
 
-  unsigned clear_count() { return mock_service_->clear_count(); }
+  unsigned clear_count() const { return mock_service_->clear_count(); }
 
-  DomainReliabilityClearMode last_clear_mode() {
+  DomainReliabilityClearMode last_clear_mode() const {
     return mock_service_->last_clear_mode();
   }
 
  private:
   void AttachService() {
     const void* kKey = TestingDomainReliabilityServiceFactoryUserData::kKey;
 
     // Attach kludgey UserData struct to profile.
     TestingDomainReliabilityServiceFactoryUserData* data =
         new TestingDomainReliabilityServiceFactoryUserData(profile_,
@@ skipping 13 matching lines @@
   }
 
   TestingProfile* profile_;
   MockDomainReliabilityService* mock_service_;
 };
 
 // Test Class ----------------------------------------------------------------
 
 class BrowsingDataRemoverTest : public testing::Test {
  public:
-  BrowsingDataRemoverTest() : profile_(new TestingProfile()) {
+  BrowsingDataRemoverTest()
+      : profile_(new TestingProfile()),
+        clear_domain_reliability_tester_(GetProfile()) {
     callback_subscription_ =
         BrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
             base::Bind(&BrowsingDataRemoverTest::NotifyWithDetails,
                        base::Unretained(this)));
   }
 
   ~BrowsingDataRemoverTest() override {}
 
   void TearDown() override {
 #if defined(ENABLE_EXTENSIONS)
     mock_policy_ = NULL;
 #endif
 
     // TestingProfile contains a DOMStorageContext.  BrowserContext's destructor
     // posts a message to the WEBKIT thread to delete some of its member
     // variables. We need to ensure that the profile is destroyed, and that
     // the message loop is cleared out, before destroying the threads and loop.
     // Otherwise we leak memory.
     profile_.reset();
     base::MessageLoop::current()->RunUntilIdle();
+
+    TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
   }
 
   void BlockUntilBrowsingDataRemoved(BrowsingDataRemover::TimePeriod period,
                                      int remove_mask,
                                      bool include_protected_origins) {
     BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
         profile_.get(), period);
 
     TestStoragePartition storage_partition;
     remover->OverrideStoragePartitionForTesting(&storage_partition);
@@ skipping 87 matching lines @@
   // If |kOrigin1| is protected when extensions are enabled, the expected
   // result for tests where the OriginMatcherFunction result is variable.
   bool ShouldRemoveForProtectedOriginOne() const {
 #if defined(ENABLE_EXTENSIONS)
     return false;
 #else
     return true;
 #endif
   }
 
+  const ClearDomainReliabilityTester& clear_domain_reliability_tester() {
+    return clear_domain_reliability_tester_;
+  }
+
  protected:
   scoped_ptr<BrowsingDataRemover::NotificationDetails> called_with_details_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
 
   StoragePartitionRemovalData storage_partition_removal_data_;
 
 #if defined(ENABLE_EXTENSIONS)
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy_;
 #endif
 
   BrowsingDataRemover::CallbackSubscription callback_subscription_;
 
+  // Needed to mock out DomainReliabilityService, even for unrelated tests.
+  ClearDomainReliabilityTester clear_domain_reliability_tester_;
+
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTest);
 };
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookieForever) {
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
                                 BrowsingDataRemover::REMOVE_COOKIES,
                                 false);
 
@@ skipping 906 matching lines @@
 
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_CONTENT_LICENSES, false);
 
   chromeos::DBusThreadManager::Shutdown();
 }
 #endif
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Null) {
-  ClearDomainReliabilityTester tester(GetProfile());
+  const ClearDomainReliabilityTester& tester =
+      clear_domain_reliability_tester();
 
   EXPECT_EQ(0u, tester.clear_count());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Beacons) {
-  ClearDomainReliabilityTester tester(GetProfile());
+  const ClearDomainReliabilityTester& tester =
+      clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Contexts) {
-  ClearDomainReliabilityTester tester(GetProfile());
+  const ClearDomainReliabilityTester& tester =
+      clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_COOKIES, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_ContextsWin) {
-  ClearDomainReliabilityTester tester(GetProfile());
+  const ClearDomainReliabilityTester& tester =
+      clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_HISTORY |
       BrowsingDataRemover::REMOVE_COOKIES, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_ProtectedOrigins) {
-  ClearDomainReliabilityTester tester(GetProfile());
+  const ClearDomainReliabilityTester& tester =
+      clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_COOKIES, true);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
-TEST_F(BrowsingDataRemoverTest, DomainReliability_NoMonitor) {
+// TODO(ttuttle): This isn't actually testing the no-monitor case, since

[Bernhard Bauer, 2015/02/09 18:19:04]

So, what's the TODO here?

[Deprecated (see juliatuttle), 2015/02/09 18:35:11]

Done.

+// BrowsingDataRemoverTest now creates one unconditionally, since it's needed
+// for some unrelated test cases.
+TEST_F(BrowsingDataRemoverTest, DISABLED_DomainReliability_NoMonitor) {
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_HISTORY |
       BrowsingDataRemover::REMOVE_COOKIES, false);
 }