Reset profile: reset cookies and site data.

Fixed Profile Reset unit tests.

BUG=235037

Review URL: https://chromiumcodereview.appspot.com/17274006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@207833 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/profile_resetter/profile_resetter.cc

@@ -5,6 +5,7 @@
 #include "chrome/browser/profile_resetter/profile_resetter.h"
 
 #include "base/prefs/pref_service.h"
+#include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/management_policy.h"
@@ -24,14 +25,18 @@
 ProfileResetter::ProfileResetter(Profile* profile)
     : profile_(profile),
       template_url_service_(TemplateURLServiceFactory::GetForProfile(profile_)),
-      pending_reset_flags_(0) {
+      pending_reset_flags_(0),
+      cookies_remover_(NULL) {
   DCHECK(CalledOnValidThread());
   DCHECK(profile_);
   registrar_.Add(this, chrome::NOTIFICATION_TEMPLATE_URL_SERVICE_LOADED,
                  content::Source<TemplateURLService>(template_url_service_));
 }
 
-ProfileResetter::~ProfileResetter() {}
+ProfileResetter::~ProfileResetter() {
+  if (cookies_remover_)
+    cookies_remover_->RemoveObserver(this);
+}
 
 void ProfileResetter::Reset(ProfileResetter::ResettableFlags resettable_flags,
                             const base::Closure& callback) {
@@ -137,9 +142,18 @@ void ProfileResetter::ResetContentSettings() {
 
 void ProfileResetter::ResetCookiesAndSiteData() {
   DCHECK(CalledOnValidThread());
-  NOTIMPLEMENTED();
-  // TODO(battre/vabr): Implement
-  MarkAsDone(COOKIES_AND_SITE_DATA);
+  DCHECK(!cookies_remover_);
+
+  cookies_remover_ = BrowsingDataRemover::CreateForUnboundedRange(profile_);
+  cookies_remover_->AddObserver(this);
+  int remove_mask = BrowsingDataRemover::REMOVE_SITE_DATA |
+                    BrowsingDataRemover::REMOVE_CACHE;
+  PrefService* prefs = profile_->GetPrefs();
+  DCHECK(prefs);
+  // Don't try to clear LSO data if it's not supported.
+  if (!prefs->GetBoolean(prefs::kClearPluginLSODataEnabled))
+    remove_mask &= ~BrowsingDataRemover::REMOVE_PLUGIN_DATA;
+  cookies_remover_->Remove(remove_mask, BrowsingDataHelper::UNPROTECTED_WEB);
 }
 
 void ProfileResetter::ResetExtensions() {
@@ -187,3 +201,8 @@ void ProfileResetter::Observe(int type,
   if (pending_reset_flags_ & DEFAULT_SEARCH_ENGINE)
     ResetDefaultSearchEngine();
 }
+
+void ProfileResetter::OnBrowsingDataRemoverDone() {
+  cookies_remover_ = NULL;
+  MarkAsDone(COOKIES_AND_SITE_DATA);
+}

chrome/browser/profile_resetter/profile_resetter.h

@@ -8,6 +8,7 @@
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/threading/non_thread_safe.h"
+#include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
@@ -18,7 +19,8 @@ class TemplateURLService;
 // It is used in case the profile has been damaged due to malware or bad user
 // settings.
 class ProfileResetter : public base::NonThreadSafe,
-                        public content::NotificationObserver {
+                        public content::NotificationObserver,
+                        public BrowsingDataRemover::Observer {
  public:
   // Flags indicating what aspects of a profile shall be reset.
   enum Resettable {
@@ -70,6 +72,9 @@ class ProfileResetter : public base::NonThreadSafe,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // BrowsingDataRemover::Observer:
+  virtual void OnBrowsingDataRemoverDone() OVERRIDE;
+
   Profile* profile_;
   TemplateURLService* template_url_service_;
 
@@ -82,6 +87,10 @@ class ProfileResetter : public base::NonThreadSafe,
 
   content::NotificationRegistrar registrar_;
 
+  // If non-null it means removal is in progress. BrowsingDataRemover takes care
+  // of deleting itself when done.
+  BrowsingDataRemover* cookies_remover_;
+
   DISALLOW_COPY_AND_ASSIGN(ProfileResetter);
 };
 

chrome/browser/profile_resetter/profile_resetter_browsertest.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/profile_resetter/profile_resetter.h"
+
+#include "base/bind.h"
+#include "chrome/browser/profile_resetter/profile_resetter_test_base.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "content/public/test/test_utils.h"
+#include "net/cookies/cookie_store.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+namespace {
+
+const char kCookieDefinition[] = "A=1";
+const char kCookieHostname[] = "http://host1";
+
+using content::BrowserThread;
+
+// RemoveCookieTester provides the user with the ability to set and get a
+// cookie for given profile.
+class RemoveCookieTester {
+ public:
+  explicit RemoveCookieTester(Profile* profile);
+  ~RemoveCookieTester();
+
+  std::string GetCookie(const std::string& host);
+  void AddCookie(const std::string& host, const std::string& definition);
+
+ private:
+  void GetCookieOnIOThread(net::URLRequestContextGetter* context_getter,
+                           const std::string& host);
+  void SetCookieOnIOThread(net::URLRequestContextGetter* context_getter,
+                           const std::string& host,
+                           const std::string& definition);
+  void GetCookieCallback(const std::string& cookies);
+  void SetCookieCallback(bool result);
+
+  void BlockUntilNotified();
+  void Notify();
+
+  std::string last_cookies_;
+  bool waiting_callback_;
+  Profile* profile_;
+  scoped_refptr<content::MessageLoopRunner> runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveCookieTester);
+};
+
+RemoveCookieTester::RemoveCookieTester(Profile* profile)
+    : waiting_callback_(false),
+      profile_(profile) {
+}
+
+RemoveCookieTester::~RemoveCookieTester() {}
+
+// Returns true, if the given cookie exists in the cookie store.
+std::string RemoveCookieTester::GetCookie(const std::string& host) {
+  last_cookies_.clear();
+  DCHECK(!waiting_callback_);
+  waiting_callback_ = true;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&RemoveCookieTester::GetCookieOnIOThread,
+                 base::Unretained(this),
+                 base::Unretained(profile_->GetRequestContext()),
+                 host));
+  BlockUntilNotified();
+  return last_cookies_;
+}
+
+void RemoveCookieTester::AddCookie(const std::string& host,
+                                   const std::string& definition) {
+  DCHECK(!waiting_callback_);
+  waiting_callback_ = true;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&RemoveCookieTester::SetCookieOnIOThread,
+                 base::Unretained(this),
+                 base::Unretained(profile_->GetRequestContext()),
+                 host,
+                 definition));
+  BlockUntilNotified();
+}
+
+void RemoveCookieTester::GetCookieOnIOThread(
+    net::URLRequestContextGetter* context_getter,
+    const std::string& host) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::CookieStore* cookie_store = context_getter->
+      GetURLRequestContext()->cookie_store();
+  cookie_store->GetCookiesWithOptionsAsync(
+      GURL(host), net::CookieOptions(),
+      base::Bind(&RemoveCookieTester::GetCookieCallback,
+                 base::Unretained(this)));
+}
+
+void RemoveCookieTester::SetCookieOnIOThread(
+    net::URLRequestContextGetter* context_getter,
+    const std::string& host,
+    const std::string& definition) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::CookieStore* cookie_store = context_getter->
+      GetURLRequestContext()->cookie_store();
+  cookie_store->SetCookieWithOptionsAsync(
+      GURL(host), definition, net::CookieOptions(),
+      base::Bind(&RemoveCookieTester::SetCookieCallback,
+                 base::Unretained(this)));
+}
+
+void RemoveCookieTester::GetCookieCallback(const std::string& cookies) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&RemoveCookieTester::GetCookieCallback,
+                   base::Unretained(this), cookies));
+    return;
+  }
+  last_cookies_ = cookies;
+  Notify();
+}
+
+void RemoveCookieTester::SetCookieCallback(bool result) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&RemoveCookieTester::SetCookieCallback,
+                   base::Unretained(this), result));
+    return;
+  }
+  ASSERT_TRUE(result);
+  Notify();
+}
+
+void RemoveCookieTester::BlockUntilNotified() {
+  DCHECK(!runner_);
+  if (waiting_callback_) {
+    runner_ = new content::MessageLoopRunner;
+    runner_->Run();
+    runner_ = NULL;
+  }
+}
+
+void RemoveCookieTester::Notify() {
+  DCHECK(waiting_callback_);
+  waiting_callback_ = false;
+  if (runner_)
+    runner_->Quit();
+}
+
+class ProfileResetTest : public InProcessBrowserTest,
+                         public ProfileResetterTestBase {
+ protected:
+  virtual void SetUpOnMainThread() OVERRIDE {
+    resetter_.reset(new ProfileResetter(browser()->profile()));
+  }
+};
+
+
+IN_PROC_BROWSER_TEST_F(ProfileResetTest, ResetCookiesAndSiteData) {
+  RemoveCookieTester tester(browser()->profile());
+  tester.AddCookie(kCookieHostname, kCookieDefinition);
+  ASSERT_EQ(kCookieDefinition, tester.GetCookie(kCookieHostname));
+
+  resetter_->Reset(ProfileResetter::COOKIES_AND_SITE_DATA,
+                   base::Bind(&ProfileResetterMockObject::StopLoop,
+                              base::Unretained(&mock_object_)));
+  mock_object_.RunLoop();
+
+  EXPECT_EQ("", tester.GetCookie(kCookieHostname));
+}
+
+}  // namespace

chrome/browser/profile_resetter/profile_resetter_test_base.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/profile_resetter/profile_resetter_test_base.h"
+
+#include "chrome/browser/profile_resetter/profile_resetter.h"
+
+ProfileResetterMockObject::ProfileResetterMockObject() {}
+
+ProfileResetterMockObject::~ProfileResetterMockObject() {}
+
+void ProfileResetterMockObject::RunLoop() {
+  EXPECT_CALL(*this, Callback());
+  runner_ = new content::MessageLoopRunner;
+  runner_->Run();
+}
+
+void ProfileResetterMockObject::StopLoop() {
+  DCHECK(runner_.get());
+  Callback();
+  runner_->Quit();
+}
+
+ProfileResetterTestBase::ProfileResetterTestBase() {}
+
+ProfileResetterTestBase::~ProfileResetterTestBase() {}

chrome/browser/profile_resetter/profile_resetter_test_base.h

+// 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.
+
+#ifndef CHROME_BROWSER_PROFILE_RESETTER_PROFILE_RESETTER_TEST_BASE_H_
+#define CHROME_BROWSER_PROFILE_RESETTER_PROFILE_RESETTER_TEST_BASE_H_
+
+#include "content/public/test/test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+class ProfileResetter;
+
+// The ProfileResetterMockObject is used to block the thread until
+// ProfileResetter::Reset has completed:
+
+// ProfileResetterMockObject mock_object;
+// resetter_->Reset(ProfileResetter::ALL,
+//                  base::Bind(&ProfileResetterMockObject::StopLoop,
+//                             base::Unretained(&mock_object)));
+// mock_object.RunLoop();
+class ProfileResetterMockObject {
+ public:
+  ProfileResetterMockObject();
+  ~ProfileResetterMockObject();
+
+  void RunLoop();
+  void StopLoop();
+
+ private:
+  MOCK_METHOD0(Callback, void(void));
+
+  scoped_refptr<content::MessageLoopRunner> runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProfileResetterMockObject);
+};
+
+// Base class for all ProfileResetter unit tests.
+class ProfileResetterTestBase {
+ public:
+  ProfileResetterTestBase();
+  ~ProfileResetterTestBase();
+
+ protected:
+  testing::StrictMock<ProfileResetterMockObject> mock_object_;
+  scoped_ptr<ProfileResetter> resetter_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ProfileResetterTestBase);
+};
+
+#endif  // CHROME_BROWSER_PROFILE_RESETTER_PROFILE_RESETTER_TEST_BASE_H_

chrome/browser/profile_resetter/profile_resetter_unittest.cc

@@ -4,11 +4,11 @@
 
 #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"
@@ -17,52 +17,14 @@
 #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:
@@ -95,9 +57,6 @@ void ExtensionsResetTest::SetUp() {
   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,
@@ -140,10 +99,17 @@ content::WebContents* PinnedTabsResetTest::CreateWebContents() {
 /********************* 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) {
@@ -155,7 +121,8 @@ TEST_F(ProfileResetterTest, ResetHomepage) {
 
   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));
@@ -166,14 +133,8 @@ TEST_F(ProfileResetterTest, ResetHomepage) {
 TEST_F(ProfileResetterTest, ResetContentSettings) {
   resetter_->Reset(
       ProfileResetter::CONTENT_SETTINGS,
-      base::Bind(&MockObject::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_)));
+      base::Bind(&ProfileResetterMockObject::StopLoop,
+                 base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 }
 
@@ -216,7 +177,8 @@ TEST_F(ExtensionsResetTest, ResetExtensionsByDisabling) {
 
   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());
@@ -236,7 +198,8 @@ TEST_F(ProfileResetterTest, ResetStartPage) {
 
   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);
@@ -250,20 +213,20 @@ TEST_F(PinnedTabsResetTest, ResetPinnedTabs) {
       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));
@@ -274,7 +237,8 @@ TEST_F(PinnedTabsResetTest, ResetPinnedTabs) {
 
   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));
@@ -288,7 +252,8 @@ 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();
 }
 

chrome/chrome_tests.gypi

@@ -1506,6 +1506,7 @@
         'browser/profiles/avatar_menu_model_browsertest.cc',
         'browser/profiles/profile_browsertest.cc',
         'browser/profiles/profile_manager_browsertest.cc',
+        'browser/profile_resetter/profile_resetter_browsertest.cc',
         'browser/referrer_policy_browsertest.cc',
         'browser/renderer_host/render_process_host_chrome_browsertest.cc',
         'browser/renderer_host/web_cache_manager_browsertest.cc',

chrome/chrome_tests_unit.gypi

@@ -158,6 +158,8 @@
         'browser/policy/test/local_policy_test_server.h',
         'browser/prefs/pref_service_mock_builder.cc',
         'browser/prefs/pref_service_mock_builder.h',
+        'browser/profile_resetter/profile_resetter_test_base.cc',
+        'browser/profile_resetter/profile_resetter_test_base.h',
         'browser/search_engines/template_url_service_test_util.cc',
         'browser/search_engines/template_url_service_test_util.h',
         'browser/sessions/session_service_test_helper.cc',