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 85 matching lines @@
         base::Bind(&RemoveCookieTester::SetCookieCallback,
                    base::Unretained(this)));
     BlockUntilNotified();
   }
 
  private:
   void GetCookieCallback(const std::string& cookies) {
     if (cookies == "A=1") {
       get_cookie_success_ = true;
     } else {
-      EXPECT_EQ(cookies, "");
+      EXPECT_EQ("", cookies);
       get_cookie_success_ = false;
     }
     Notify();
   }
 
   void SetCookieCallback(bool result) {
     ASSERT_TRUE(result);
     Notify();
   }
 
@@ skipping 93 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_.get()));
   }
 
   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_details_.reset(new BrowsingDataRemover::NotificationDetails());
+
     // BrowsingDataRemover deletes itself when it completes.
     remover->Remove(remove_mask);
     tester->BlockUntilNotified();
   }
 
   TestingProfile* GetProfile() {
     return profile_.get();
   }
 
+  base::Time GetBeginTime() {
+    return called_with_details_->removal_begin;
+  }
+
+  int GetRemovalMask() {
+    return called_with_details_->removal_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 storing a copy of
+    // it locally.
+    called_with_details_.reset(new BrowsingDataRemover::NotificationDetails(
+        *content::Details<BrowsingDataRemover::NotificationDetails>(
+            details).ptr()));
+
+    registrar_.RemoveAll();
+  }
+
  private:
+  scoped_ptr<BrowsingDataRemover::NotificationDetails> called_with_details_;
+  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(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA, GetRemovalMask());
   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(BrowsingDataRemover::REMOVE_SITE_DATA &
+      ~BrowsingDataRemover::REMOVE_LSO_DATA, GetRemovalMask());
   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