OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/sessions/restore_on_startup_policy_handler.h" | 5 #include "chrome/browser/sessions/restore_on_startup_policy_handler.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <string> | 8 #include <string> |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
46 private: | 46 private: |
47 PolicyMap policies_; | 47 PolicyMap policies_; |
48 PolicyErrorMap errors_; | 48 PolicyErrorMap errors_; |
49 PrefValueMap prefs_; | 49 PrefValueMap prefs_; |
50 RestoreOnStartupPolicyHandler handler_; | 50 RestoreOnStartupPolicyHandler handler_; |
51 }; | 51 }; |
52 | 52 |
53 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_FailsTypeCheck) { | 53 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_FailsTypeCheck) { |
54 // Handler expects an int; pass it a bool. | 54 // Handler expects an int; pass it a bool. |
55 SetPolicyValue(key::kRestoreOnStartup, | 55 SetPolicyValue(key::kRestoreOnStartup, |
56 base::MakeUnique<base::FundamentalValue>(false)); | 56 base::MakeUnique<base::Value>(false)); |
57 // Checking should fail and add an error to the error map. | 57 // Checking should fail and add an error to the error map. |
58 EXPECT_FALSE(CheckPolicySettings()); | 58 EXPECT_FALSE(CheckPolicySettings()); |
59 ASSERT_EQ(1U, errors().size()); | 59 ASSERT_EQ(1U, errors().size()); |
60 EXPECT_EQ( | 60 EXPECT_EQ( |
61 l10n_util::GetStringFUTF16(IDS_POLICY_TYPE_ERROR, | 61 l10n_util::GetStringFUTF16(IDS_POLICY_TYPE_ERROR, |
62 base::ASCIIToUTF16(base::Value::GetTypeName( | 62 base::ASCIIToUTF16(base::Value::GetTypeName( |
63 base::Value::TYPE_INTEGER))), | 63 base::Value::TYPE_INTEGER))), |
64 errors().begin()->second); | 64 errors().begin()->second); |
65 } | 65 } |
66 | 66 |
67 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_Unspecified) { | 67 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_Unspecified) { |
68 // Don't specify a value for the policy. | 68 // Don't specify a value for the policy. |
69 // Checking should succeed with no errors. | 69 // Checking should succeed with no errors. |
70 EXPECT_TRUE(CheckPolicySettings()); | 70 EXPECT_TRUE(CheckPolicySettings()); |
71 EXPECT_TRUE(errors().empty()); | 71 EXPECT_TRUE(errors().empty()); |
72 } | 72 } |
73 | 73 |
74 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_UnknownValue) { | 74 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_UnknownValue) { |
75 // Specify an unknown value for the policy. | 75 // Specify an unknown value for the policy. |
76 int impossible_value = SessionStartupPref::kPrefValueLast + | 76 int impossible_value = SessionStartupPref::kPrefValueLast + |
77 SessionStartupPref::kPrefValueURLs + | 77 SessionStartupPref::kPrefValueURLs + |
78 SessionStartupPref::kPrefValueNewTab; | 78 SessionStartupPref::kPrefValueNewTab; |
79 SetPolicyValue(key::kRestoreOnStartup, | 79 SetPolicyValue(key::kRestoreOnStartup, |
80 base::MakeUnique<base::FundamentalValue>(impossible_value)); | 80 base::MakeUnique<base::Value>(impossible_value)); |
81 // Checking should succeed but add an error to the error map. | 81 // Checking should succeed but add an error to the error map. |
82 EXPECT_TRUE(CheckPolicySettings()); | 82 EXPECT_TRUE(CheckPolicySettings()); |
83 ASSERT_EQ(1U, errors().size()); | 83 ASSERT_EQ(1U, errors().size()); |
84 EXPECT_EQ(l10n_util::GetStringFUTF16( | 84 EXPECT_EQ(l10n_util::GetStringFUTF16( |
85 IDS_POLICY_OUT_OF_RANGE_ERROR, | 85 IDS_POLICY_OUT_OF_RANGE_ERROR, |
86 base::ASCIIToUTF16(base::IntToString(impossible_value))), | 86 base::ASCIIToUTF16(base::IntToString(impossible_value))), |
87 errors().begin()->second); | 87 errors().begin()->second); |
88 } | 88 } |
89 | 89 |
90 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_HomePage) { | 90 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_HomePage) { |
91 // Specify the HomePage value. | 91 // Specify the HomePage value. |
92 SetPolicyValue(key::kRestoreOnStartup, | 92 SetPolicyValue(key::kRestoreOnStartup, |
93 // kPrefValueHomePage, deprecated. | 93 // kPrefValueHomePage, deprecated. |
94 base::MakeUnique<base::FundamentalValue>(0)); | 94 base::MakeUnique<base::Value>(0)); |
95 // Checking should succeed but add an error to the error map. | 95 // Checking should succeed but add an error to the error map. |
96 EXPECT_TRUE(CheckPolicySettings()); | 96 EXPECT_TRUE(CheckPolicySettings()); |
97 ASSERT_EQ(1U, errors().size()); | 97 ASSERT_EQ(1U, errors().size()); |
98 EXPECT_EQ(l10n_util::GetStringUTF16(IDS_POLICY_VALUE_DEPRECATED), | 98 EXPECT_EQ(l10n_util::GetStringUTF16(IDS_POLICY_VALUE_DEPRECATED), |
99 errors().begin()->second); | 99 errors().begin()->second); |
100 } | 100 } |
101 | 101 |
102 TEST_F(RestoreOnStartupPolicyHandlerTest, | 102 TEST_F(RestoreOnStartupPolicyHandlerTest, |
103 CheckPolicySettings_RestoreLastSession_SessionCookies) { | 103 CheckPolicySettings_RestoreLastSession_SessionCookies) { |
104 // Specify the Last value and the Session-Only Cookies value. | 104 // Specify the Last value and the Session-Only Cookies value. |
105 SetPolicyValue(key::kRestoreOnStartup, | 105 SetPolicyValue(key::kRestoreOnStartup, |
106 base::WrapUnique(new base::FundamentalValue( | 106 base::WrapUnique(new base::Value( |
107 SessionStartupPref::kPrefValueLast))); | 107 SessionStartupPref::kPrefValueLast))); |
108 std::unique_ptr<base::ListValue> urls(new base::ListValue); | 108 std::unique_ptr<base::ListValue> urls(new base::ListValue); |
109 urls->AppendString("http://foo.com"); | 109 urls->AppendString("http://foo.com"); |
110 SetPolicyValue(key::kCookiesSessionOnlyForUrls, std::move(urls)); | 110 SetPolicyValue(key::kCookiesSessionOnlyForUrls, std::move(urls)); |
111 // Checking should succeed but add an error to the error map. | 111 // Checking should succeed but add an error to the error map. |
112 EXPECT_TRUE(CheckPolicySettings()); | 112 EXPECT_TRUE(CheckPolicySettings()); |
113 ASSERT_EQ(1U, errors().size()); | 113 ASSERT_EQ(1U, errors().size()); |
114 EXPECT_EQ(key::kCookiesSessionOnlyForUrls, errors().begin()->first); | 114 EXPECT_EQ(key::kCookiesSessionOnlyForUrls, errors().begin()->first); |
115 EXPECT_EQ(l10n_util::GetStringFUTF16( | 115 EXPECT_EQ(l10n_util::GetStringFUTF16( |
116 IDS_POLICY_OVERRIDDEN, | 116 IDS_POLICY_OVERRIDDEN, |
117 base::ASCIIToUTF16(key::kRestoreOnStartup)), | 117 base::ASCIIToUTF16(key::kRestoreOnStartup)), |
118 errors().begin()->second); | 118 errors().begin()->second); |
119 } | 119 } |
120 | 120 |
121 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NotHomePage) { | 121 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NotHomePage) { |
122 // Specify anything except the HomePage value. | 122 // Specify anything except the HomePage value. |
123 int not_home_page = 1; // kPrefValueHomePage + 1, deprecated. | 123 int not_home_page = 1; // kPrefValueHomePage + 1, deprecated. |
124 SetPolicyValue(key::kRestoreOnStartup, | 124 SetPolicyValue(key::kRestoreOnStartup, |
125 base::MakeUnique<base::FundamentalValue>(not_home_page)); | 125 base::MakeUnique<base::Value>(not_home_page)); |
126 ApplyPolicySettings(); | 126 ApplyPolicySettings(); |
127 // The resulting prefs should have the value we specified. | 127 // The resulting prefs should have the value we specified. |
128 int result; | 128 int result; |
129 EXPECT_TRUE(prefs().GetInteger(prefs::kRestoreOnStartup, &result)); | 129 EXPECT_TRUE(prefs().GetInteger(prefs::kRestoreOnStartup, &result)); |
130 EXPECT_EQ(not_home_page, result); | 130 EXPECT_EQ(not_home_page, result); |
131 } | 131 } |
132 | 132 |
133 TEST_F(RestoreOnStartupPolicyHandlerTest, | 133 TEST_F(RestoreOnStartupPolicyHandlerTest, |
134 CheckPolicySettings_RestoreLastSession_ClearDataOnExit) { | 134 CheckPolicySettings_RestoreLastSession_ClearDataOnExit) { |
135 // Specify the Last value and the Clear-Data-On-Exit value. | 135 // Specify the Last value and the Clear-Data-On-Exit value. |
136 SetPolicyValue(key::kRestoreOnStartup, | 136 SetPolicyValue(key::kRestoreOnStartup, |
137 base::WrapUnique(new base::FundamentalValue( | 137 base::WrapUnique(new base::Value( |
138 SessionStartupPref::kPrefValueLast))); | 138 SessionStartupPref::kPrefValueLast))); |
139 SetPolicyValue(key::kClearSiteDataOnExit, | 139 SetPolicyValue(key::kClearSiteDataOnExit, |
140 base::MakeUnique<base::FundamentalValue>(true)); | 140 base::MakeUnique<base::Value>(true)); |
141 // Checking should succeed but add an error to the error map. | 141 // Checking should succeed but add an error to the error map. |
142 EXPECT_TRUE(CheckPolicySettings()); | 142 EXPECT_TRUE(CheckPolicySettings()); |
143 ASSERT_EQ(1U, errors().size()); | 143 ASSERT_EQ(1U, errors().size()); |
144 EXPECT_EQ(key::kClearSiteDataOnExit, errors().begin()->first); | 144 EXPECT_EQ(key::kClearSiteDataOnExit, errors().begin()->first); |
145 EXPECT_EQ(l10n_util::GetStringFUTF16( | 145 EXPECT_EQ(l10n_util::GetStringFUTF16( |
146 IDS_POLICY_OVERRIDDEN, | 146 IDS_POLICY_OVERRIDDEN, |
147 base::ASCIIToUTF16(key::kRestoreOnStartup)), | 147 base::ASCIIToUTF16(key::kRestoreOnStartup)), |
148 errors().begin()->second); | 148 errors().begin()->second); |
149 } | 149 } |
150 | 150 |
151 TEST_F(RestoreOnStartupPolicyHandlerTest, | 151 TEST_F(RestoreOnStartupPolicyHandlerTest, |
152 CheckPolicySettings_RestoreLastSession) { | 152 CheckPolicySettings_RestoreLastSession) { |
153 // Specify the Last value without the conflicts. | 153 // Specify the Last value without the conflicts. |
154 SetPolicyValue(key::kRestoreOnStartup, | 154 SetPolicyValue(key::kRestoreOnStartup, |
155 base::WrapUnique(new base::FundamentalValue( | 155 base::WrapUnique(new base::Value( |
156 SessionStartupPref::kPrefValueLast))); | 156 SessionStartupPref::kPrefValueLast))); |
157 // Checking should succeed with no errors. | 157 // Checking should succeed with no errors. |
158 EXPECT_TRUE(CheckPolicySettings()); | 158 EXPECT_TRUE(CheckPolicySettings()); |
159 EXPECT_TRUE(errors().empty()); | 159 EXPECT_TRUE(errors().empty()); |
160 } | 160 } |
161 | 161 |
162 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_URLs) { | 162 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_URLs) { |
163 // Specify the URLs value. | 163 // Specify the URLs value. |
164 SetPolicyValue(key::kRestoreOnStartup, | 164 SetPolicyValue(key::kRestoreOnStartup, |
165 base::WrapUnique(new base::FundamentalValue( | 165 base::WrapUnique(new base::Value( |
166 SessionStartupPref::kPrefValueURLs))); | 166 SessionStartupPref::kPrefValueURLs))); |
167 // Checking should succeed with no errors. | 167 // Checking should succeed with no errors. |
168 EXPECT_TRUE(CheckPolicySettings()); | 168 EXPECT_TRUE(CheckPolicySettings()); |
169 EXPECT_TRUE(errors().empty()); | 169 EXPECT_TRUE(errors().empty()); |
170 } | 170 } |
171 | 171 |
172 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_NewTab) { | 172 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_NewTab) { |
173 // Specify the NewTab value. | 173 // Specify the NewTab value. |
174 SetPolicyValue(key::kRestoreOnStartup, | 174 SetPolicyValue(key::kRestoreOnStartup, |
175 base::WrapUnique(new base::FundamentalValue( | 175 base::WrapUnique(new base::Value( |
176 SessionStartupPref::kPrefValueNewTab))); | 176 SessionStartupPref::kPrefValueNewTab))); |
177 // Checking should succeed with no errors. | 177 // Checking should succeed with no errors. |
178 EXPECT_TRUE(CheckPolicySettings()); | 178 EXPECT_TRUE(CheckPolicySettings()); |
179 EXPECT_TRUE(errors().empty()); | 179 EXPECT_TRUE(errors().empty()); |
180 } | 180 } |
181 | 181 |
182 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NoValue) { | 182 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NoValue) { |
183 // Don't specify a value for the policy. | 183 // Don't specify a value for the policy. |
184 ApplyPolicySettings(); | 184 ApplyPolicySettings(); |
185 // The resulting prefs should be empty. | 185 // The resulting prefs should be empty. |
186 EXPECT_TRUE(prefs().empty()); | 186 EXPECT_TRUE(prefs().empty()); |
187 } | 187 } |
188 | 188 |
189 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_WrongType) { | 189 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_WrongType) { |
190 // Handler expects an int; pass it a bool. | 190 // Handler expects an int; pass it a bool. |
191 SetPolicyValue(key::kRestoreOnStartup, | 191 SetPolicyValue(key::kRestoreOnStartup, |
192 base::MakeUnique<base::FundamentalValue>(false)); | 192 base::MakeUnique<base::Value>(false)); |
193 // The resulting prefs should be empty. | 193 // The resulting prefs should be empty. |
194 EXPECT_TRUE(prefs().empty()); | 194 EXPECT_TRUE(prefs().empty()); |
195 } | 195 } |
196 | 196 |
197 } // namespace policy | 197 } // namespace policy |
OLD | NEW |