Adding chrome::NOTIFICATION_BROWSING_DATA_REMOVED.

chrome/browser/browsing_data_remover_unittest.cc

 // Copyright (c) 2011 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_remover.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
 #include "chrome/browser/history/history.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/notification_service.h"
 #include "content/test/test_browser_thread.h"
 #include "net/base/cookie_monster.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
@@ skipping 199 matching lines @@
     EXPECT_TRUE(manager->OriginHasData(kOrigin3,
         quota::kStorageTypeTemporary));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RemoveQuotaManagedDataTester);
 };
 
 // Test Class ----------------------------------------------------------------
 
-class BrowsingDataRemoverTest : public testing::Test {
+class BrowsingDataRemoverTest : public testing::Test,
+                                public content::NotificationObserver {
  public:
   BrowsingDataRemoverTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         db_thread_(BrowserThread::DB, &message_loop_),
         webkit_thread_(BrowserThread::WEBKIT, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         profile_(new TestingProfile()) {
+    registrar_.Add(this, chrome::NOTIFICATION_BROWSING_DATA_REMOVED,
+                   content::Source<Profile>(profile_->GetOriginalProfile()));
   }
 
   virtual ~BrowsingDataRemoverTest() {
   }
 
   void TearDown() {
     // TestingProfile contains a WebKitContext.  WebKitContext'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();
     message_loop_.RunAllPending();
   }
 
   void BlockUntilBrowsingDataRemoved(BrowsingDataRemover::TimePeriod period,
                                      int remove_mask,
                                      BrowsingDataRemoverTester* tester) {
     BrowsingDataRemover* remover = new BrowsingDataRemover(
         profile_.get(), period,
         base::Time::Now() + base::TimeDelta::FromMilliseconds(10));
     remover->AddObserver(tester);
 
+    called_with_mask_ = 0;
+    called_with_time_ = base::Time();
+
     // BrowsingDataRemover deletes itself when it completes.
     remover->Remove(remove_mask);
     tester->BlockUntilNotified();
   }
 
   TestingProfile* GetProfile() {
     return profile_.get();
   }
 
+  base::Time GetBeginTime() {
+    return called_with_time_;
+  }
+
+  int GetRemovalMask() {
+    return called_with_mask_;
+  }
+
   quota::MockQuotaManager* GetMockManager() {
     if (profile_->GetQuotaManager() == NULL) {
       profile_->SetQuotaManager(new quota::MockQuotaManager(
         profile_->IsOffTheRecord(),
         profile_->GetPath(),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
         profile_->GetExtensionSpecialStoragePolicy()));
     }
     return (quota::MockQuotaManager*) profile_->GetQuotaManager();
   }
 
+  // content::NotificationObserver implementation.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE {
+    DCHECK_EQ(type, chrome::NOTIFICATION_BROWSING_DATA_REMOVED);
+
+    // We're not taking ownership of the details object, but simply storing
+    // copies of its contents.
+    BrowsingDataRemover::NotificationDetail* remover_detail(
+        content::Details<BrowsingDataRemover::NotificationDetail>(
+            details).ptr());
+    called_with_time_ = remover_detail->removal_begin;
+    called_with_mask_ = remover_detail->removal_mask;
+
+    registrar_.RemoveAll();
+  }
+
  private:
+  base::Time called_with_time_;

[jochen (gone - plz use gerrit), 2011/12/13 13:18:48]

what about just storing a NotificationDetails object here, instead of the
individual fields?

[Mike West, 2011/12/13 14:23:26]

Done, though I'm not convinced it's any prettier. :)

+  int called_with_mask_;
+  content::NotificationRegistrar registrar_;
+
   // message_loop_, as well as all the threads associated with it must be
   // defined before profile_ to prevent explosions. Oh how I love C++.
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   content::TestBrowserThread webkit_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
   scoped_ptr<TestingProfile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTest);
 };
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookieForever) {
   scoped_ptr<RemoveCookieTester> tester(
       new RemoveCookieTester(GetProfile()));
 
   tester->AddCookie();
   ASSERT_TRUE(tester->ContainsCookie());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_COOKIES, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_COOKIES);

[jochen (gone - plz use gerrit), 2011/12/13 13:18:48]

EXPECT_EQ takes expected, actual as parameters IIRC, not the other way round
(here and everywhere else in this file)

[Mike West, 2011/12/13 14:23:26]

Needle, haystack. Haystack, needle. What... you mean C++ isn't PHP? :)

Done.

   EXPECT_FALSE(tester->ContainsCookie());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForever) {
   scoped_ptr<RemoveHistoryTester> tester(
       new RemoveHistoryTester(GetProfile()));
 
   tester->AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_HISTORY, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_HISTORY);
   EXPECT_FALSE(tester->HistoryContainsURL(kOrigin1));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForLastHour) {
   scoped_ptr<RemoveHistoryTester> tester(
       new RemoveHistoryTester(GetProfile()));
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester->AddHistory(kOrigin1, base::Time::Now());
   tester->AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin2));
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
       BrowsingDataRemover::REMOVE_HISTORY, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_HISTORY);
   EXPECT_FALSE(tester->HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester->HistoryContainsURL(kOrigin2));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverBoth) {
   scoped_ptr<RemoveQuotaManagedDataTester> tester(
       new RemoveQuotaManagedDataTester());
 
   tester->PopulateTestQuotaManagedData(GetMockManager());
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_SITE_DATA &
       ~BrowsingDataRemover::REMOVE_LSO_DATA, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA);
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyTemporary) {
   scoped_ptr<RemoveQuotaManagedDataTester> tester(
       new RemoveQuotaManagedDataTester());
 
   tester->PopulateTestQuotaManagedTemporaryData(GetMockManager());
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_SITE_DATA &
       ~BrowsingDataRemover::REMOVE_LSO_DATA, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA);
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyPersistent) {
   scoped_ptr<RemoveQuotaManagedDataTester> tester(
       new RemoveQuotaManagedDataTester());
 
   tester->PopulateTestQuotaManagedPersistentData(GetMockManager());
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_SITE_DATA &
       ~BrowsingDataRemover::REMOVE_LSO_DATA, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA);
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverNeither) {
   scoped_ptr<RemoveQuotaManagedDataTester> tester(
       new RemoveQuotaManagedDataTester());
 
   GetMockManager();  // Creates the QuotaManager instance.
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_SITE_DATA &
       ~BrowsingDataRemover::REMOVE_LSO_DATA, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA);
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastHour) {
   scoped_ptr<RemoveQuotaManagedDataTester> tester(
       new RemoveQuotaManagedDataTester());
   tester->PopulateTestQuotaManagedData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
       BrowsingDataRemover::REMOVE_SITE_DATA &
       ~BrowsingDataRemover::REMOVE_LSO_DATA, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA);
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypeTemporary));
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastWeek) {
   scoped_ptr<RemoveQuotaManagedDataTester> tester(
       new RemoveQuotaManagedDataTester());
   tester->PopulateTestQuotaManagedData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_WEEK,
       BrowsingDataRemover::REMOVE_SITE_DATA &
       ~BrowsingDataRemover::REMOVE_LSO_DATA, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA);
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedUnprotectedOrigins) {
   // Protect kOrigin1.
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
           new MockExtensionSpecialStoragePolicy;
   mock_policy->AddProtected(kOrigin1.GetOrigin());
   GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy);
 
   scoped_ptr<RemoveQuotaManagedDataTester> tester(
       new RemoveQuotaManagedDataTester());
   tester->PopulateTestQuotaManagedData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_SITE_DATA &
       ~BrowsingDataRemover::REMOVE_LSO_DATA, tester.get());
 
+  EXPECT_EQ(GetRemovalMask(), BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA);
   EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 }  // namespace