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 | 10 |
10 #include "base/compiler_specific.h" | 11 #include "base/compiler_specific.h" |
| 12 #include "base/memory/ptr_util.h" |
11 #include "base/strings/string_number_conversions.h" | 13 #include "base/strings/string_number_conversions.h" |
12 #include "base/strings/utf_string_conversions.h" | 14 #include "base/strings/utf_string_conversions.h" |
13 #include "base/values.h" | 15 #include "base/values.h" |
14 #include "chrome/browser/prefs/session_startup_pref.h" | 16 #include "chrome/browser/prefs/session_startup_pref.h" |
15 #include "chrome/common/pref_names.h" | 17 #include "chrome/common/pref_names.h" |
16 #include "components/policy/core/browser/configuration_policy_handler.h" | 18 #include "components/policy/core/browser/configuration_policy_handler.h" |
17 #include "components/policy/core/browser/policy_error_map.h" | 19 #include "components/policy/core/browser/policy_error_map.h" |
18 #include "components/policy/core/common/policy_map.h" | 20 #include "components/policy/core/common/policy_map.h" |
19 #include "components/policy/core/common/policy_types.h" | 21 #include "components/policy/core/common/policy_types.h" |
20 #include "components/prefs/pref_value_map.h" | 22 #include "components/prefs/pref_value_map.h" |
21 #include "grit/components_strings.h" | 23 #include "grit/components_strings.h" |
22 #include "policy/policy_constants.h" | 24 #include "policy/policy_constants.h" |
23 #include "testing/gtest/include/gtest/gtest.h" | 25 #include "testing/gtest/include/gtest/gtest.h" |
24 #include "ui/base/l10n/l10n_util.h" | 26 #include "ui/base/l10n/l10n_util.h" |
25 | 27 |
26 namespace policy { | 28 namespace policy { |
27 | 29 |
28 class RestoreOnStartupPolicyHandlerTest : public testing::Test { | 30 class RestoreOnStartupPolicyHandlerTest : public testing::Test { |
29 protected: | 31 protected: |
30 void SetPolicyValue(const std::string& policy, base::Value* value) { | 32 void SetPolicyValue(const std::string& policy, |
31 policies_.Set( | 33 std::unique_ptr<base::Value> value) { |
32 policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, | 34 policies_.Set(policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
33 value, nullptr); | 35 POLICY_SOURCE_CLOUD, std::move(value), nullptr); |
34 } | 36 } |
35 bool CheckPolicySettings() { | 37 bool CheckPolicySettings() { |
36 return handler_.CheckPolicySettings(policies_, &errors_); | 38 return handler_.CheckPolicySettings(policies_, &errors_); |
37 } | 39 } |
38 void ApplyPolicySettings() { | 40 void ApplyPolicySettings() { |
39 handler_.ApplyPolicySettings(policies_, &prefs_); | 41 handler_.ApplyPolicySettings(policies_, &prefs_); |
40 } | 42 } |
41 PolicyErrorMap& errors() { return errors_; } | 43 PolicyErrorMap& errors() { return errors_; } |
42 PrefValueMap& prefs() { return prefs_; } | 44 PrefValueMap& prefs() { return prefs_; } |
43 | 45 |
44 private: | 46 private: |
45 PolicyMap policies_; | 47 PolicyMap policies_; |
46 PolicyErrorMap errors_; | 48 PolicyErrorMap errors_; |
47 PrefValueMap prefs_; | 49 PrefValueMap prefs_; |
48 RestoreOnStartupPolicyHandler handler_; | 50 RestoreOnStartupPolicyHandler handler_; |
49 }; | 51 }; |
50 | 52 |
51 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_FailsTypeCheck) { | 53 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_FailsTypeCheck) { |
52 // Handler expects an int; pass it a bool. | 54 // Handler expects an int; pass it a bool. |
53 SetPolicyValue(key::kRestoreOnStartup, new base::FundamentalValue(false)); | 55 SetPolicyValue(key::kRestoreOnStartup, |
| 56 base::WrapUnique(new base::FundamentalValue(false))); |
54 // Checking should fail and add an error to the error map. | 57 // Checking should fail and add an error to the error map. |
55 EXPECT_FALSE(CheckPolicySettings()); | 58 EXPECT_FALSE(CheckPolicySettings()); |
56 EXPECT_EQ(1U, errors().size()); | 59 EXPECT_EQ(1U, errors().size()); |
57 EXPECT_EQ(l10n_util::GetStringFUTF16( | 60 EXPECT_EQ(l10n_util::GetStringFUTF16( |
58 IDS_POLICY_TYPE_ERROR, | 61 IDS_POLICY_TYPE_ERROR, |
59 base::ASCIIToUTF16( | 62 base::ASCIIToUTF16( |
60 ConfigurationPolicyHandler::ValueTypeToString( | 63 ConfigurationPolicyHandler::ValueTypeToString( |
61 base::Value::TYPE_INTEGER))), | 64 base::Value::TYPE_INTEGER))), |
62 errors().begin()->second); | 65 errors().begin()->second); |
63 } | 66 } |
64 | 67 |
65 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_Unspecified) { | 68 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_Unspecified) { |
66 // Don't specify a value for the policy. | 69 // Don't specify a value for the policy. |
67 // Checking should succeed with no errors. | 70 // Checking should succeed with no errors. |
68 EXPECT_TRUE(CheckPolicySettings()); | 71 EXPECT_TRUE(CheckPolicySettings()); |
69 EXPECT_EQ(0U, errors().size()); | 72 EXPECT_EQ(0U, errors().size()); |
70 } | 73 } |
71 | 74 |
72 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_UnknownValue) { | 75 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_UnknownValue) { |
73 // Specify an unknown value for the policy. | 76 // Specify an unknown value for the policy. |
74 int impossible_value = SessionStartupPref::kPrefValueLast + | 77 int impossible_value = SessionStartupPref::kPrefValueLast + |
75 SessionStartupPref::kPrefValueURLs + | 78 SessionStartupPref::kPrefValueURLs + |
76 SessionStartupPref::kPrefValueNewTab; | 79 SessionStartupPref::kPrefValueNewTab; |
77 SetPolicyValue(key::kRestoreOnStartup, | 80 SetPolicyValue( |
78 new base::FundamentalValue(impossible_value)); | 81 key::kRestoreOnStartup, |
| 82 base::WrapUnique(new base::FundamentalValue(impossible_value))); |
79 // Checking should succeed but add an error to the error map. | 83 // Checking should succeed but add an error to the error map. |
80 EXPECT_TRUE(CheckPolicySettings()); | 84 EXPECT_TRUE(CheckPolicySettings()); |
81 EXPECT_EQ(1U, errors().size()); | 85 EXPECT_EQ(1U, errors().size()); |
82 EXPECT_EQ(l10n_util::GetStringFUTF16( | 86 EXPECT_EQ(l10n_util::GetStringFUTF16( |
83 IDS_POLICY_OUT_OF_RANGE_ERROR, | 87 IDS_POLICY_OUT_OF_RANGE_ERROR, |
84 base::ASCIIToUTF16(base::IntToString(impossible_value))), | 88 base::ASCIIToUTF16(base::IntToString(impossible_value))), |
85 errors().begin()->second); | 89 errors().begin()->second); |
86 } | 90 } |
87 | 91 |
88 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_HomePage) { | 92 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_HomePage) { |
89 // Specify the HomePage value. | 93 // Specify the HomePage value. |
90 SetPolicyValue( | 94 SetPolicyValue(key::kRestoreOnStartup, |
91 key::kRestoreOnStartup, | 95 // kPrefValueHomePage, deprecated. |
92 new base::FundamentalValue(0)); // kPrefValueHomePage, deprecated. | 96 base::WrapUnique(new base::FundamentalValue(0))); |
93 // Checking should succeed but add an error to the error map. | 97 // Checking should succeed but add an error to the error map. |
94 EXPECT_TRUE(CheckPolicySettings()); | 98 EXPECT_TRUE(CheckPolicySettings()); |
95 EXPECT_EQ(1U, errors().size()); | 99 EXPECT_EQ(1U, errors().size()); |
96 EXPECT_EQ(l10n_util::GetStringUTF16(IDS_POLICY_VALUE_DEPRECATED), | 100 EXPECT_EQ(l10n_util::GetStringUTF16(IDS_POLICY_VALUE_DEPRECATED), |
97 errors().begin()->second); | 101 errors().begin()->second); |
98 } | 102 } |
99 | 103 |
100 TEST_F(RestoreOnStartupPolicyHandlerTest, | 104 TEST_F(RestoreOnStartupPolicyHandlerTest, |
101 CheckPolicySettings_RestoreLastSession_SessionCookies) { | 105 CheckPolicySettings_RestoreLastSession_SessionCookies) { |
102 // Specify the Last value and the Session-Only Cookies value. | 106 // Specify the Last value and the Session-Only Cookies value. |
103 SetPolicyValue( | 107 SetPolicyValue(key::kRestoreOnStartup, |
104 key::kRestoreOnStartup, | 108 base::WrapUnique(new base::FundamentalValue( |
105 new base::FundamentalValue(SessionStartupPref::kPrefValueLast)); | 109 SessionStartupPref::kPrefValueLast))); |
106 std::unique_ptr<base::ListValue> urls(new base::ListValue); | 110 std::unique_ptr<base::ListValue> urls(new base::ListValue); |
107 urls->AppendString("http://foo.com"); | 111 urls->AppendString("http://foo.com"); |
108 SetPolicyValue(key::kCookiesSessionOnlyForUrls, urls.release()); | 112 SetPolicyValue(key::kCookiesSessionOnlyForUrls, std::move(urls)); |
109 // Checking should succeed but add an error to the error map. | 113 // Checking should succeed but add an error to the error map. |
110 EXPECT_TRUE(CheckPolicySettings()); | 114 EXPECT_TRUE(CheckPolicySettings()); |
111 EXPECT_EQ(1U, errors().size()); | 115 EXPECT_EQ(1U, errors().size()); |
112 EXPECT_TRUE(key::kCookiesSessionOnlyForUrls == errors().begin()->first); | 116 EXPECT_TRUE(key::kCookiesSessionOnlyForUrls == errors().begin()->first); |
113 EXPECT_EQ(l10n_util::GetStringFUTF16( | 117 EXPECT_EQ(l10n_util::GetStringFUTF16( |
114 IDS_POLICY_OVERRIDDEN, | 118 IDS_POLICY_OVERRIDDEN, |
115 base::ASCIIToUTF16(key::kRestoreOnStartup)), | 119 base::ASCIIToUTF16(key::kRestoreOnStartup)), |
116 errors().begin()->second); | 120 errors().begin()->second); |
117 } | 121 } |
118 | 122 |
119 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NotHomePage) { | 123 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NotHomePage) { |
120 // Specify anything except the HomePage value. | 124 // Specify anything except the HomePage value. |
121 int not_home_page = 1; // kPrefValueHomePage + 1, deprecated. | 125 int not_home_page = 1; // kPrefValueHomePage + 1, deprecated. |
122 SetPolicyValue(key::kRestoreOnStartup, | 126 SetPolicyValue(key::kRestoreOnStartup, |
123 new base::FundamentalValue(not_home_page)); | 127 base::WrapUnique(new base::FundamentalValue(not_home_page))); |
124 ApplyPolicySettings(); | 128 ApplyPolicySettings(); |
125 // The resulting prefs should have the value we specified. | 129 // The resulting prefs should have the value we specified. |
126 int result; | 130 int result; |
127 EXPECT_TRUE(prefs().GetInteger(prefs::kRestoreOnStartup, &result)); | 131 EXPECT_TRUE(prefs().GetInteger(prefs::kRestoreOnStartup, &result)); |
128 EXPECT_EQ(not_home_page, result); | 132 EXPECT_EQ(not_home_page, result); |
129 } | 133 } |
130 | 134 |
131 TEST_F(RestoreOnStartupPolicyHandlerTest, | 135 TEST_F(RestoreOnStartupPolicyHandlerTest, |
132 CheckPolicySettings_RestoreLastSession_ClearDataOnExit) { | 136 CheckPolicySettings_RestoreLastSession_ClearDataOnExit) { |
133 // Specify the Last value and the Clear-Data-On-Exit value. | 137 // Specify the Last value and the Clear-Data-On-Exit value. |
134 SetPolicyValue( | 138 SetPolicyValue(key::kRestoreOnStartup, |
135 key::kRestoreOnStartup, | 139 base::WrapUnique(new base::FundamentalValue( |
136 new base::FundamentalValue(SessionStartupPref::kPrefValueLast)); | 140 SessionStartupPref::kPrefValueLast))); |
137 SetPolicyValue(key::kClearSiteDataOnExit, new base::FundamentalValue(true)); | 141 SetPolicyValue(key::kClearSiteDataOnExit, |
| 142 base::WrapUnique(new base::FundamentalValue(true))); |
138 // Checking should succeed but add an error to the error map. | 143 // Checking should succeed but add an error to the error map. |
139 EXPECT_TRUE(CheckPolicySettings()); | 144 EXPECT_TRUE(CheckPolicySettings()); |
140 EXPECT_EQ(1U, errors().size()); | 145 EXPECT_EQ(1U, errors().size()); |
141 EXPECT_TRUE(key::kClearSiteDataOnExit == errors().begin()->first); | 146 EXPECT_TRUE(key::kClearSiteDataOnExit == errors().begin()->first); |
142 EXPECT_EQ(l10n_util::GetStringFUTF16( | 147 EXPECT_EQ(l10n_util::GetStringFUTF16( |
143 IDS_POLICY_OVERRIDDEN, | 148 IDS_POLICY_OVERRIDDEN, |
144 base::ASCIIToUTF16(key::kRestoreOnStartup)), | 149 base::ASCIIToUTF16(key::kRestoreOnStartup)), |
145 errors().begin()->second); | 150 errors().begin()->second); |
146 } | 151 } |
147 | 152 |
148 TEST_F(RestoreOnStartupPolicyHandlerTest, | 153 TEST_F(RestoreOnStartupPolicyHandlerTest, |
149 CheckPolicySettings_RestoreLastSession) { | 154 CheckPolicySettings_RestoreLastSession) { |
150 // Specify the Last value without the conflicts. | 155 // Specify the Last value without the conflicts. |
151 SetPolicyValue( | 156 SetPolicyValue(key::kRestoreOnStartup, |
152 key::kRestoreOnStartup, | 157 base::WrapUnique(new base::FundamentalValue( |
153 new base::FundamentalValue(SessionStartupPref::kPrefValueLast)); | 158 SessionStartupPref::kPrefValueLast))); |
154 // Checking should succeed with no errors. | 159 // Checking should succeed with no errors. |
155 EXPECT_TRUE(CheckPolicySettings()); | 160 EXPECT_TRUE(CheckPolicySettings()); |
156 EXPECT_EQ(0U, errors().size()); | 161 EXPECT_EQ(0U, errors().size()); |
157 } | 162 } |
158 | 163 |
159 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_URLs) { | 164 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_URLs) { |
160 // Specify the URLs value. | 165 // Specify the URLs value. |
161 SetPolicyValue( | 166 SetPolicyValue(key::kRestoreOnStartup, |
162 key::kRestoreOnStartup, | 167 base::WrapUnique(new base::FundamentalValue( |
163 new base::FundamentalValue(SessionStartupPref::kPrefValueURLs)); | 168 SessionStartupPref::kPrefValueURLs))); |
164 // Checking should succeed with no errors. | 169 // Checking should succeed with no errors. |
165 EXPECT_TRUE(CheckPolicySettings()); | 170 EXPECT_TRUE(CheckPolicySettings()); |
166 EXPECT_EQ(0U, errors().size()); | 171 EXPECT_EQ(0U, errors().size()); |
167 } | 172 } |
168 | 173 |
169 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_NewTab) { | 174 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_NewTab) { |
170 // Specify the NewTab value. | 175 // Specify the NewTab value. |
171 SetPolicyValue( | 176 SetPolicyValue(key::kRestoreOnStartup, |
172 key::kRestoreOnStartup, | 177 base::WrapUnique(new base::FundamentalValue( |
173 new base::FundamentalValue(SessionStartupPref::kPrefValueNewTab)); | 178 SessionStartupPref::kPrefValueNewTab))); |
174 // Checking should succeed with no errors. | 179 // Checking should succeed with no errors. |
175 EXPECT_TRUE(CheckPolicySettings()); | 180 EXPECT_TRUE(CheckPolicySettings()); |
176 EXPECT_EQ(0U, errors().size()); | 181 EXPECT_EQ(0U, errors().size()); |
177 } | 182 } |
178 | 183 |
179 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NoValue) { | 184 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NoValue) { |
180 // Don't specify a value for the policy. | 185 // Don't specify a value for the policy. |
181 ApplyPolicySettings(); | 186 ApplyPolicySettings(); |
182 // The resulting prefs should be empty. | 187 // The resulting prefs should be empty. |
183 EXPECT_TRUE(prefs().begin() == prefs().end()); | 188 EXPECT_TRUE(prefs().begin() == prefs().end()); |
184 } | 189 } |
185 | 190 |
186 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_WrongType) { | 191 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_WrongType) { |
187 // Handler expects an int; pass it a bool. | 192 // Handler expects an int; pass it a bool. |
188 SetPolicyValue(key::kRestoreOnStartup, new base::FundamentalValue(false)); | 193 SetPolicyValue(key::kRestoreOnStartup, |
| 194 base::WrapUnique(new base::FundamentalValue(false))); |
189 // The resulting prefs should be empty. | 195 // The resulting prefs should be empty. |
190 EXPECT_TRUE(prefs().begin() == prefs().end()); | 196 EXPECT_TRUE(prefs().begin() == prefs().end()); |
191 } | 197 } |
192 | 198 |
193 } // namespace policy | 199 } // namespace policy |
OLD | NEW |