Reset profile: reset cookies and site data.

chrome/browser/profile_resetter/profile_resetter_unittest.cc

 // Copyright (c) 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/profile_resetter/profile_resetter.h"
 
-#include "base/bind.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
+#include "chrome/browser/profile_resetter/profile_resetter_test_base.h"
 #include "chrome/browser/search_engines/template_url_service_test_util.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
-#include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/test/test_utils.h"
-#include "testing/gmock/include/gmock/gmock.h"
+
 
 namespace {
 
 using extensions::Extension;
 using extensions::Manifest;
 
-class MockObject {
- public:
-  void RunLoop() {
-    EXPECT_CALL(*this, Callback());
-    runner_ = new content::MessageLoopRunner;
-    runner_->Run();
-  }
-
-  void StopLoop() {
-    DCHECK(runner_.get());
-    Callback();
-    runner_->Quit();
-  }
-
- private:
-  MOCK_METHOD0(Callback, void(void));
-
-  scoped_refptr<content::MessageLoopRunner> runner_;
-};
-
-class ProfileResetterTestBase {
- public:
-  ProfileResetterTestBase();
-  ~ProfileResetterTestBase();
- protected:
-  testing::StrictMock<MockObject> mock_object_;
-  scoped_ptr<ProfileResetter> resetter_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ProfileResetterTestBase);
-};
-
-ProfileResetterTestBase::ProfileResetterTestBase() {}
-
-ProfileResetterTestBase::~ProfileResetterTestBase() {}
-
 class ProfileResetterTest : public testing::Test,
                             public ProfileResetterTestBase {
  protected:
   // testing::Test:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   TemplateURLServiceTestUtil test_util_;
 };
 
@@ skipping 12 matching lines @@
  protected:
   virtual void SetUp() OVERRIDE;
 };
 
 void ExtensionsResetTest::SetUp() {
   ExtensionServiceTestBase::SetUp();
   InitializeEmptyExtensionService();
   resetter_.reset(new ProfileResetter(profile_.get()));
 }
 
-// Returns a barebones test Extension object with the specified |name|.  The
-// returned extension will include background permission iff
-// |background_permission| is true.
 scoped_refptr<Extension> CreateExtension(const std::string& name,
                                          const base::FilePath& path,
                                          Manifest::Location location,
                                          bool theme) {
   DictionaryValue manifest;
   manifest.SetString(extension_manifest_keys::kVersion, "1.0.0.0");
   manifest.SetString(extension_manifest_keys::kName, name);
   manifest.SetString("app.launch.web_url", "http://www.google.com");
   if (theme)
     manifest.Set(extension_manifest_keys::kTheme, new DictionaryValue());
@@ skipping 22 matching lines @@
 }
 
 content::WebContents* PinnedTabsResetTest::CreateWebContents() {
   return content::WebContents::Create(
       content::WebContents::CreateParams(profile()));
 }
 
 /********************* Tests *********************/
 
 TEST_F(ProfileResetterTest, ResetDefaultSearchEngine) {
+  PrefService* prefs = test_util_.profile()->GetPrefs();
+  DCHECK(prefs);
+  prefs->SetString(prefs::kLastPromptedGoogleURL, "http://www.foo.com/");
+
   resetter_->Reset(
       ProfileResetter::DEFAULT_SEARCH_ENGINE,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
+
+  EXPECT_EQ("", prefs->GetString(prefs::kLastPromptedGoogleURL));
 }
 
 TEST_F(ProfileResetterTest, ResetHomepage) {
   PrefService* prefs = test_util_.profile()->GetPrefs();
   DCHECK(prefs);
   prefs->SetBoolean(prefs::kHomePageIsNewTabPage, false);
   prefs->SetString(prefs::kHomePage, "http://google.com");
   prefs->SetBoolean(prefs::kShowHomeButton, true);
 
   resetter_->Reset(
       ProfileResetter::HOMEPAGE,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 
   EXPECT_TRUE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage));
   EXPECT_EQ(std::string(), prefs->GetString(prefs::kHomePage));
   EXPECT_FALSE(prefs->GetBoolean(prefs::kShowHomeButton));
 }
 
 TEST_F(ProfileResetterTest, ResetContentSettings) {
   resetter_->Reset(
       ProfileResetter::CONTENT_SETTINGS,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 }
 
-TEST_F(ProfileResetterTest, ResetCookiesAndSiteData) {
-  resetter_->Reset(
-      ProfileResetter::COOKIES_AND_SITE_DATA,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
-  mock_object_.RunLoop();
-}
-
 TEST_F(ExtensionsResetTest, ResetExtensionsByDisabling) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   scoped_refptr<Extension> theme = CreateExtension("example1", temp_dir.path(),
                                                    Manifest::INVALID_LOCATION,
                                                    true);
   service_->FinishInstallationForTest(theme.get());
   // Let ThemeService finish creating the theme pack.
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 19 matching lines @@
   scoped_refptr<Extension> ext4 =
       CreateExtension("example4",
                       base::FilePath(FILE_PATH_LITERAL("//nonexistent3")),
                       Manifest::EXTERNAL_POLICY_DOWNLOAD,
                       false);
   service_->AddExtension(ext4.get());
   EXPECT_EQ(4u, service_->extensions()->size());
 
   resetter_->Reset(
       ProfileResetter::EXTENSIONS,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 
   EXPECT_EQ(2u, service_->extensions()->size());
   EXPECT_TRUE(service_->extensions()->Contains(ext3->id()));
   EXPECT_TRUE(service_->extensions()->Contains(ext4->id()));
   EXPECT_TRUE(theme_service->UsingDefaultTheme());
 }
 
 TEST_F(ProfileResetterTest, ResetStartPage) {
   PrefService* prefs = test_util_.profile()->GetPrefs();
   DCHECK(prefs);
 
   SessionStartupPref startup_pref(SessionStartupPref::URLS);
   startup_pref.urls.push_back(GURL("http://foo"));
   startup_pref.urls.push_back(GURL("http://bar"));
   SessionStartupPref::SetStartupPref(prefs, startup_pref);
 
   resetter_->Reset(
       ProfileResetter::STARTUP_PAGES,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 
   startup_pref = SessionStartupPref::GetStartupPref(prefs);
   EXPECT_EQ(SessionStartupPref::GetDefaultStartupType(), startup_pref.type);
   EXPECT_EQ(std::vector<GURL>(), startup_pref.urls);
 }
 
 TEST_F(PinnedTabsResetTest, ResetPinnedTabs) {
   scoped_refptr<Extension> extension_app = CreateExtension(
       "hello!",
       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
       Manifest::INVALID_LOCATION,
       false);
-  content::WebContents* contents1 = CreateWebContents();
-  extensions::TabHelper::CreateForWebContents(contents1);
-  extensions::TabHelper::FromWebContents(contents1)->
+  scoped_ptr<content::WebContents> contents1(CreateWebContents());
+  extensions::TabHelper::CreateForWebContents(contents1.get());
+  extensions::TabHelper::FromWebContents(contents1.get())->
       SetExtensionApp(extension_app.get());
-  content::WebContents* contents2 = CreateWebContents();
-  content::WebContents* contents3 = CreateWebContents();
-  content::WebContents* contents4 = CreateWebContents();
+  scoped_ptr<content::WebContents> contents2(CreateWebContents());
+  scoped_ptr<content::WebContents> contents3(CreateWebContents());
+  scoped_ptr<content::WebContents> contents4(CreateWebContents());
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
 
-  tab_strip_model->AppendWebContents(contents4, true);
-  tab_strip_model->AppendWebContents(contents3, true);
-  tab_strip_model->AppendWebContents(contents2, true);
+  tab_strip_model->AppendWebContents(contents4.get(), true);
+  tab_strip_model->AppendWebContents(contents3.get(), true);
+  tab_strip_model->AppendWebContents(contents2.get(), true);
   tab_strip_model->SetTabPinned(2, true);
-  tab_strip_model->AppendWebContents(contents1, true);
+  tab_strip_model->AppendWebContents(contents1.get(), true);
   tab_strip_model->SetTabPinned(3, true);
 
   EXPECT_EQ(contents2, tab_strip_model->GetWebContentsAt(0));
   EXPECT_EQ(contents1, tab_strip_model->GetWebContentsAt(1));
   EXPECT_EQ(contents3, tab_strip_model->GetWebContentsAt(2));
   EXPECT_EQ(contents4, tab_strip_model->GetWebContentsAt(3));
   EXPECT_EQ(3, tab_strip_model->IndexOfFirstNonMiniTab());
 
   resetter_->Reset(
       ProfileResetter::PINNED_TABS,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 
   EXPECT_EQ(contents1, tab_strip_model->GetWebContentsAt(0));
   EXPECT_EQ(contents2, tab_strip_model->GetWebContentsAt(1));
   EXPECT_EQ(contents3, tab_strip_model->GetWebContentsAt(2));
   EXPECT_EQ(contents4, tab_strip_model->GetWebContentsAt(3));
   EXPECT_EQ(1, tab_strip_model->IndexOfFirstNonMiniTab());
 }
 
 TEST_F(ProfileResetterTest, ResetFewFlags) {
   // mock_object_ is a StrictMock, so we verify that it is called only once.
   resetter_->Reset(
       ProfileResetter::DEFAULT_SEARCH_ENGINE | ProfileResetter::HOMEPAGE,
-      base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 }
 
 }  // namespace