1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/prefs/session_startup_pref.h"
6#include "chrome/common/pref_names.h"
7#include "chrome/test/base/testing_pref_service_syncable.h"
8#include "components/pref_registry/pref_registry_syncable.h"
9#include "testing/gmock/include/gmock/gmock.h"
10#include "testing/gtest/include/gtest/gtest.h"
11
12#if defined(OS_MACOSX)
13#include "chrome/browser/ui/cocoa/window_restore_utils.h"
14#endif
15
16// Unit tests for SessionStartupPref.
17class SessionStartupPrefTest : public testing::Test {
18 public:
19  virtual void SetUp() {
20    pref_service_.reset(new TestingPrefServiceSyncable);
21    SessionStartupPref::RegisterProfilePrefs(registry());
22    registry()->RegisterBooleanPref(
23        prefs::kHomePageIsNewTabPage,
24        true,
25        user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
26    // Make the tests independent of the Mac startup pref migration (see
27    // SessionStartupPref::MigrateMacDefaultPrefIfNecessary).
28    registry()->RegisterStringPref(
29        prefs::kProfileCreatedByVersion,
30        "22.0.0.0",
31        user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
32  }
33
34  bool IsUseLastOpenDefault() {
35    // On ChromeOS, the default SessionStartupPref is LAST.
36#if defined(OS_CHROMEOS)
37    return true;
38#else
39    return false;
40#endif
41  }
42
43  user_prefs::PrefRegistrySyncable* registry() {
44    return pref_service_->registry();
45  }
46
47  scoped_ptr<TestingPrefServiceSyncable> pref_service_;
48};
49
50TEST_F(SessionStartupPrefTest, URLListIsFixedUp) {
51  base::ListValue* url_pref_list = new base::ListValue;
52  url_pref_list->Set(0, new base::StringValue("google.com"));
53  url_pref_list->Set(1, new base::StringValue("chromium.org"));
54  pref_service_->SetUserPref(prefs::kURLsToRestoreOnStartup, url_pref_list);
55
56  SessionStartupPref result =
57      SessionStartupPref::GetStartupPref(pref_service_.get());
58  EXPECT_EQ(2u, result.urls.size());
59  EXPECT_EQ("http://google.com/", result.urls[0].spec());
60  EXPECT_EQ("http://chromium.org/", result.urls[1].spec());
61}
62
63TEST_F(SessionStartupPrefTest, URLListManagedOverridesUser) {
64  base::ListValue* url_pref_list1 = new base::ListValue;
65  url_pref_list1->Set(0, new base::StringValue("chromium.org"));
66  pref_service_->SetUserPref(prefs::kURLsToRestoreOnStartup, url_pref_list1);
67
68  base::ListValue* url_pref_list2 = new base::ListValue;
69  url_pref_list2->Set(0, new base::StringValue("chromium.org"));
70  url_pref_list2->Set(1, new base::StringValue("chromium.org"));
71  url_pref_list2->Set(2, new base::StringValue("chromium.org"));
72  pref_service_->SetManagedPref(prefs::kURLsToRestoreOnStartup,
73                                url_pref_list2);
74
75  SessionStartupPref result =
76      SessionStartupPref::GetStartupPref(pref_service_.get());
77  EXPECT_EQ(3u, result.urls.size());
78
79  SessionStartupPref override_test =
80      SessionStartupPref(SessionStartupPref::URLS);
81  override_test.urls.push_back(GURL("dev.chromium.org"));
82  SessionStartupPref::SetStartupPref(pref_service_.get(), override_test);
83
84  result = SessionStartupPref::GetStartupPref(pref_service_.get());
85  EXPECT_EQ(3u, result.urls.size());
86}
87
88// Checks to make sure that if the user had previously not selected anything
89// (so that, in effect, the default value "Open the homepage" was selected),
90// their preferences are migrated on upgrade to m19.
91TEST_F(SessionStartupPrefTest, DefaultMigration) {
92  registry()->RegisterStringPref(
93      prefs::kHomePage,
94      "http://google.com/",
95      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
96  pref_service_->SetString(prefs::kHomePage, "http://chromium.org/");
97  pref_service_->SetBoolean(prefs::kHomePageIsNewTabPage, false);
98
99  EXPECT_FALSE(pref_service_->HasPrefPath(prefs::kRestoreOnStartup));
100
101  SessionStartupPref pref = SessionStartupPref::GetStartupPref(
102      pref_service_.get());
103
104  if (IsUseLastOpenDefault()) {
105    EXPECT_EQ(SessionStartupPref::LAST, pref.type);
106    EXPECT_EQ(0U, pref.urls.size());
107  } else {
108    EXPECT_EQ(SessionStartupPref::URLS, pref.type);
109    EXPECT_EQ(1U, pref.urls.size());
110    EXPECT_EQ(GURL("http://chromium.org/"), pref.urls[0]);
111  }
112}
113
114// Checks to make sure that if the user had previously not selected anything
115// (so that, in effect, the default value "Open the homepage" was selected),
116// and the NTP is being used for the homepage, their preferences are migrated
117// to "Open the New Tab Page" on upgrade to M19.
118TEST_F(SessionStartupPrefTest, DefaultMigrationHomepageIsNTP) {
119  registry()->RegisterStringPref(
120      prefs::kHomePage,
121      "http://google.com/",
122      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
123  pref_service_->SetString(prefs::kHomePage, "http://chromium.org/");
124  pref_service_->SetBoolean(prefs::kHomePageIsNewTabPage, true);
125
126  EXPECT_FALSE(pref_service_->HasPrefPath(prefs::kRestoreOnStartup));
127
128  SessionStartupPref pref = SessionStartupPref::GetStartupPref(
129      pref_service_.get());
130
131  if (IsUseLastOpenDefault())
132    EXPECT_EQ(SessionStartupPref::LAST, pref.type);
133  else
134    EXPECT_EQ(SessionStartupPref::DEFAULT, pref.type);
135
136  // The "URLs to restore on startup" shouldn't get migrated.
137  EXPECT_EQ(0U, pref.urls.size());
138}
139
140// Checks to make sure that if the user had previously selected "Open the
141// "homepage", their preferences are migrated on upgrade to M19.
142TEST_F(SessionStartupPrefTest, HomePageMigration) {
143  registry()->RegisterStringPref(
144      prefs::kHomePage,
145      "http://google.com/",
146      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
147
148  // By design, it's impossible to set the 'restore on startup' pref to 0
149  // ("open the homepage") using SessionStartupPref::SetStartupPref(), so set it
150  // using the pref service directly.
151  pref_service_->SetInteger(prefs::kRestoreOnStartup, /*kPrefValueHomePage*/ 0);
152  pref_service_->SetString(prefs::kHomePage, "http://chromium.org/");
153  pref_service_->SetBoolean(prefs::kHomePageIsNewTabPage, false);
154
155  SessionStartupPref pref = SessionStartupPref::GetStartupPref(
156      pref_service_.get());
157
158  EXPECT_EQ(SessionStartupPref::URLS, pref.type);
159  EXPECT_EQ(1U, pref.urls.size());
160  EXPECT_EQ(GURL("http://chromium.org/"), pref.urls[0]);
161}
162
163// Checks to make sure that if the user had previously selected "Open the
164// "homepage", and the NTP is being used for the homepage, their preferences
165// are migrated on upgrade to M19.
166TEST_F(SessionStartupPrefTest, HomePageMigrationHomepageIsNTP) {
167  registry()->RegisterStringPref(
168      prefs::kHomePage,
169      "http://google.com/",
170      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
171
172  // By design, it's impossible to set the 'restore on startup' pref to 0
173  // ("open the homepage") using SessionStartupPref::SetStartupPref(), so set it
174  // using the pref service directly.
175  pref_service_->SetInteger(prefs::kRestoreOnStartup, /*kPrefValueHomePage*/ 0);
176  pref_service_->SetString(prefs::kHomePage, "http://chromium.org/");
177  pref_service_->SetBoolean(prefs::kHomePageIsNewTabPage, true);
178
179  SessionStartupPref pref = SessionStartupPref::GetStartupPref(
180      pref_service_.get());
181
182  EXPECT_EQ(SessionStartupPref::DEFAULT, pref.type);
183}
184
185#if defined(OS_MACOSX)
186// See SessionStartupPref::MigrateMacDefaultPrefIfNecessary.
187TEST_F(SessionStartupPrefTest, MacDefaultStartupPrefMigration) {
188  if (!restore_utils::IsWindowRestoreEnabled())
189    return;
190
191  // Use an old profile.
192  pref_service_->SetString(prefs::kProfileCreatedByVersion, "19.0.0.0");
193  ASSERT_TRUE(SessionStartupPref::TypeIsDefault(pref_service_.get()));
194
195  // Trigger the migration.
196  SessionStartupPref pref = SessionStartupPref::GetStartupPref(
197      pref_service_.get());
198
199  // The pref is now explicit.
200  EXPECT_EQ(SessionStartupPref::LAST, pref.type);
201  EXPECT_FALSE(SessionStartupPref::TypeIsDefault(pref_service_.get()));
202}
203#endif
204