Reset profile: unpin all pinned tabs

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/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 ProfileResetterTest : public testing::Test {
+class ProfileResetterTestBase {
+ public:
+  ProfileResetterTestBase();
+  ~ProfileResetterTestBase();
  protected:
-  ProfileResetterTest();
-  ~ProfileResetterTest();
+  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;
 
-  testing::StrictMock<MockObject> mock_object_;
   TemplateURLServiceTestUtil test_util_;
-  scoped_ptr<ProfileResetter> resetter_;
-
-  DISALLOW_COPY_AND_ASSIGN(ProfileResetterTest);
 };
 
-ProfileResetterTest::ProfileResetterTest() {}
-
-ProfileResetterTest::~ProfileResetterTest() {}
-
 void ProfileResetterTest::SetUp() {
   test_util_.SetUp();
   resetter_.reset(new ProfileResetter(test_util_.profile()));
 }
 
 void ProfileResetterTest::TearDown() {
   test_util_.TearDown();
 }
 
 // ExtensionsResetTest sets up the extension service.
-class ExtensionsResetTest : public ExtensionServiceTestBase {
+class ExtensionsResetTest : public ExtensionServiceTestBase,
+                            public ProfileResetterTestBase {
  protected:
   virtual void SetUp() OVERRIDE;
-
-  testing::StrictMock<MockObject> mock_object_;
-  scoped_ptr<ProfileResetter> resetter_;
 };
 
 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());
   std::string error;
   scoped_refptr<Extension> extension = Extension::Create(
       path,
       location,
       manifest,
       Extension::NO_FLAGS,
       &error);
   EXPECT_TRUE(extension.get() != NULL) << error;
   return extension;
 }
 
+class PinnedTabsResetTest : public BrowserWithTestWindowTest,
+                            public ProfileResetterTestBase {
+ protected:
+  virtual void SetUp() OVERRIDE;
+
+  content::WebContents* CreateWebContents();
+};
+
+void PinnedTabsResetTest::SetUp() {
+  BrowserWithTestWindowTest::SetUp();
+  resetter_.reset(new ProfileResetter(profile()));
+}
+
+content::WebContents* PinnedTabsResetTest::CreateWebContents() {
+  return content::WebContents::Create(
+      content::WebContents::CreateParams(profile()));
+}
+
+/********************* Tests *********************/
 
 TEST_F(ProfileResetterTest, ResetDefaultSearchEngine) {
   resetter_->Reset(
       ProfileResetter::DEFAULT_SEARCH_ENGINE,
-      ProfileResetter::DISABLE_EXTENSIONS,
       base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 }
 
 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,
-      ProfileResetter::DISABLE_EXTENSIONS,
       base::Bind(&MockObject::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,
-      ProfileResetter::DISABLE_EXTENSIONS,
       base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 }
 
 TEST_F(ProfileResetterTest, ResetCookiesAndSiteData) {
   resetter_->Reset(
       ProfileResetter::COOKIES_AND_SITE_DATA,
-      ProfileResetter::DISABLE_EXTENSIONS,
       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();
 
-#if !defined(OS_ANDROID)
   // ThemeService isn't compiled for Android.
   ThemeService* theme_service =
       ThemeServiceFactory::GetForProfile(profile_.get());
   EXPECT_FALSE(theme_service->UsingDefaultTheme());
-#endif
 
   scoped_refptr<Extension> ext2 = CreateExtension(
       "example2",
       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
       Manifest::INVALID_LOCATION,
       false);
   service_->AddExtension(ext2.get());
   // Components and external policy extensions shouldn't be deleted.
   scoped_refptr<Extension> ext3 = CreateExtension(
       "example3",
       base::FilePath(FILE_PATH_LITERAL("//nonexistent2")),
       Manifest::COMPONENT,
       false);
   service_->AddExtension(ext3.get());
   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,
-      ProfileResetter::DISABLE_EXTENSIONS,
       base::Bind(&MockObject::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()));
-#if !defined(OS_ANDROID)
   EXPECT_TRUE(theme_service->UsingDefaultTheme());
-#endif
 }
 
 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_PAGE,
-      ProfileResetter::DISABLE_EXTENSIONS,
+      ProfileResetter::STARTUP_PAGES,
       base::Bind(&MockObject::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)->
+      SetExtensionApp(extension_app.get());
+  content::WebContents* contents2 = CreateWebContents();
+  content::WebContents* contents3 = CreateWebContents();
+  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->SetTabPinned(2, true);
+  tab_strip_model->AppendWebContents(contents1, 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_)));
+  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,
-      ProfileResetter::DISABLE_EXTENSIONS,
       base::Bind(&MockObject::StopLoop, base::Unretained(&mock_object_)));
   mock_object_.RunLoop();
 }
 
 }  // namespace