| OLD | NEW |
|---|
| (Empty) |
| 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 "base/basictypes.h" | |
| 6 #include "base/memory/ref_counted.h" | |
| 7 #include "base/memory/scoped_ptr.h" | |
| 8 #include "base/prefs/pref_store_observer_mock.h" | |
| 9 #include "base/values.h" | |
| 10 #include "chrome/browser/extensions/extension_pref_value_map.h" | |
| 11 #include "testing/gmock/include/gmock/gmock.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 namespace { | |
| 15 const char kExt1[] = "ext1"; | |
| 16 const char kExt2[] = "ext2"; | |
| 17 const char kExt3[] = "ext3"; | |
| 18 | |
| 19 const char kPref1[] = "path1.subpath"; | |
| 20 const char kPref2[] = "path2"; | |
| 21 const char kPref3[] = "path3"; | |
| 22 const char kPref4[] = "path4"; | |
| 23 } // namespace | |
| 24 | |
| 25 static base::Value* CreateVal(const char* str) { | |
| 26 return new base::StringValue(str); | |
| 27 } | |
| 28 | |
| 29 static base::Time CreateTime(int64 t) { | |
| 30 return base::Time::FromInternalValue(t); | |
| 31 } | |
| 32 | |
| 33 template <typename BASECLASS> | |
| 34 class ExtensionPrefValueMapTestBase : public BASECLASS { | |
| 35 public: | |
| 36 static const extensions::ExtensionPrefsScope kRegular = | |
| 37 extensions::kExtensionPrefsScopeRegular; | |
| 38 static const extensions::ExtensionPrefsScope kRegularOnly = | |
| 39 extensions::kExtensionPrefsScopeRegularOnly; | |
| 40 static const extensions::ExtensionPrefsScope kIncognitoPersistent = | |
| 41 extensions::kExtensionPrefsScopeIncognitoPersistent; | |
| 42 static const extensions::ExtensionPrefsScope kIncognitoSessionOnly = | |
| 43 extensions::kExtensionPrefsScopeIncognitoSessionOnly; | |
| 44 | |
| 45 // Returns an empty string if the key is not set. | |
| 46 std::string GetValue(const char * key, bool incognito) const { | |
| 47 const base::Value *value = | |
| 48 epvm_.GetEffectivePrefValue(key, incognito, NULL); | |
| 49 std::string string_value; | |
| 50 if (value) | |
| 51 value->GetAsString(&string_value); | |
| 52 return string_value; | |
| 53 } | |
| 54 | |
| 55 protected: | |
| 56 ExtensionPrefValueMap epvm_; | |
| 57 }; | |
| 58 | |
| 59 class ExtensionPrefValueMapTest | |
| 60 : public ExtensionPrefValueMapTestBase<testing::Test> { | |
| 61 }; | |
| 62 | |
| 63 // A gmock-ified implementation of PrefStore::Observer. | |
| 64 class ExtensionPrefValueMapObserverMock | |
| 65 : public ExtensionPrefValueMap::Observer { | |
| 66 public: | |
| 67 ExtensionPrefValueMapObserverMock() {} | |
| 68 virtual ~ExtensionPrefValueMapObserverMock() {} | |
| 69 | |
| 70 MOCK_METHOD1(OnPrefValueChanged, void(const std::string&)); | |
| 71 MOCK_METHOD0(OnInitializationCompleted, void()); | |
| 72 MOCK_METHOD0(OnExtensionPrefValueMapDestruction, void()); | |
| 73 | |
| 74 private: | |
| 75 DISALLOW_COPY_AND_ASSIGN(ExtensionPrefValueMapObserverMock); | |
| 76 }; | |
| 77 | |
| 78 TEST_F(ExtensionPrefValueMapTest, SetAndGetPrefValue) { | |
| 79 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 80 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 81 EXPECT_EQ("val1", GetValue(kPref1, false)); | |
| 82 }; | |
| 83 | |
| 84 TEST_F(ExtensionPrefValueMapTest, GetNotSetPrefValue) { | |
| 85 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 86 EXPECT_EQ("", GetValue(kPref1, false)); | |
| 87 }; | |
| 88 | |
| 89 // Make sure the last-installed extension wins for each preference. | |
| 90 TEST_F(ExtensionPrefValueMapTest, Override) { | |
| 91 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 92 epvm_.RegisterExtension(kExt2, CreateTime(20), true); | |
| 93 epvm_.RegisterExtension(kExt3, CreateTime(30), true); | |
| 94 | |
| 95 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 96 epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2")); | |
| 97 epvm_.SetExtensionPref(kExt3, kPref1, kRegular, CreateVal("val3")); | |
| 98 | |
| 99 epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val4")); | |
| 100 epvm_.SetExtensionPref(kExt2, kPref2, kRegular, CreateVal("val5")); | |
| 101 | |
| 102 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val6")); | |
| 103 epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val7")); | |
| 104 epvm_.SetExtensionPref(kExt1, kPref3, kRegular, CreateVal("val8")); | |
| 105 | |
| 106 EXPECT_EQ("val3", GetValue(kPref1, false)); | |
| 107 EXPECT_EQ("val5", GetValue(kPref2, false)); | |
| 108 EXPECT_EQ("val8", GetValue(kPref3, false)); | |
| 109 } | |
| 110 | |
| 111 TEST_F(ExtensionPrefValueMapTest, OverrideChecks) { | |
| 112 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 113 epvm_.RegisterExtension(kExt2, CreateTime(20), true); | |
| 114 epvm_.RegisterExtension(kExt3, CreateTime(30), true); | |
| 115 | |
| 116 EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt1, kPref1, NULL)); | |
| 117 EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt2, kPref1, NULL)); | |
| 118 EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt3, kPref1, NULL)); | |
| 119 EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt1, kPref1, false)); | |
| 120 EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt2, kPref1, false)); | |
| 121 EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt3, kPref1, false)); | |
| 122 | |
| 123 epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val1")); | |
| 124 | |
| 125 EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt1, kPref1, NULL)); | |
| 126 EXPECT_TRUE(epvm_.DoesExtensionControlPref(kExt2, kPref1, NULL)); | |
| 127 EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt3, kPref1, NULL)); | |
| 128 EXPECT_FALSE(epvm_.CanExtensionControlPref(kExt1, kPref1, false)); | |
| 129 EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt2, kPref1, false)); | |
| 130 EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt3, kPref1, false)); | |
| 131 } | |
| 132 | |
| 133 TEST_F(ExtensionPrefValueMapTest, SetAndGetPrefValueIncognito) { | |
| 134 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 135 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 136 EXPECT_EQ("val1", GetValue(kPref1, true)); | |
| 137 } | |
| 138 | |
| 139 TEST_F(ExtensionPrefValueMapTest, UninstallOnlyExtension) { | |
| 140 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 141 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 142 epvm_.UnregisterExtension(kExt1); | |
| 143 | |
| 144 EXPECT_EQ("", GetValue(kPref1, false)); | |
| 145 } | |
| 146 | |
| 147 // Tests uninstalling an extension that wasn't winning for any preferences. | |
| 148 TEST_F(ExtensionPrefValueMapTest, UninstallIrrelevantExtension) { | |
| 149 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 150 epvm_.RegisterExtension(kExt2, CreateTime(10), true); | |
| 151 | |
| 152 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 153 epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2")); | |
| 154 | |
| 155 epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val3")); | |
| 156 epvm_.SetExtensionPref(kExt2, kPref2, kRegular, CreateVal("val4")); | |
| 157 | |
| 158 epvm_.UnregisterExtension(kExt1); | |
| 159 | |
| 160 EXPECT_EQ("val2", GetValue(kPref1, false)); | |
| 161 EXPECT_EQ("val4", GetValue(kPref2, false)); | |
| 162 } | |
| 163 | |
| 164 // Tests uninstalling an extension that was winning for all preferences. | |
| 165 TEST_F(ExtensionPrefValueMapTest, UninstallExtensionFromTop) { | |
| 166 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 167 epvm_.RegisterExtension(kExt2, CreateTime(20), true); | |
| 168 epvm_.RegisterExtension(kExt3, CreateTime(30), true); | |
| 169 | |
| 170 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 171 epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2")); | |
| 172 epvm_.SetExtensionPref(kExt3, kPref1, kRegular, CreateVal("val3")); | |
| 173 | |
| 174 epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val4")); | |
| 175 epvm_.SetExtensionPref(kExt3, kPref2, kRegular, CreateVal("val5")); | |
| 176 | |
| 177 epvm_.UnregisterExtension(kExt3); | |
| 178 | |
| 179 EXPECT_EQ("val2", GetValue(kPref1, false)); | |
| 180 EXPECT_EQ("val4", GetValue(kPref2, false)); | |
| 181 } | |
| 182 | |
| 183 // Tests uninstalling an extension that was winning for only some preferences. | |
| 184 TEST_F(ExtensionPrefValueMapTest, UninstallExtensionFromMiddle) { | |
| 185 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 186 epvm_.RegisterExtension(kExt2, CreateTime(20), true); | |
| 187 epvm_.RegisterExtension(kExt3, CreateTime(30), true); | |
| 188 | |
| 189 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 190 epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2")); | |
| 191 epvm_.SetExtensionPref(kExt3, kPref1, kRegular, CreateVal("val3")); | |
| 192 | |
| 193 epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val4")); | |
| 194 epvm_.SetExtensionPref(kExt2, kPref2, kRegular, CreateVal("val5")); | |
| 195 | |
| 196 epvm_.SetExtensionPref(kExt1, kPref3, kRegular, CreateVal("val6")); | |
| 197 | |
| 198 epvm_.SetExtensionPref(kExt2, kPref4, kRegular, CreateVal("val7")); | |
| 199 | |
| 200 epvm_.UnregisterExtension(kExt2); | |
| 201 | |
| 202 EXPECT_EQ("val3", GetValue(kPref1, false)); | |
| 203 EXPECT_EQ("val4", GetValue(kPref2, false)); | |
| 204 EXPECT_EQ("val6", GetValue(kPref3, false)); | |
| 205 EXPECT_EQ("", GetValue(kPref4, false)); | |
| 206 } | |
| 207 | |
| 208 // Tests triggering of notifications to registered observers. | |
| 209 TEST_F(ExtensionPrefValueMapTest, NotifyWhenNeeded) { | |
| 210 using testing::Mock; | |
| 211 using testing::StrEq; | |
| 212 | |
| 213 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 214 | |
| 215 ExtensionPrefValueMapObserverMock observer; | |
| 216 epvm_.AddObserver(&observer); | |
| 217 | |
| 218 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))); | |
| 219 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 220 Mock::VerifyAndClearExpectations(&observer); | |
| 221 | |
| 222 // Write the same value again. | |
| 223 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))).Times(0); | |
| 224 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 225 Mock::VerifyAndClearExpectations(&observer); | |
| 226 | |
| 227 // Override incognito value. | |
| 228 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))); | |
| 229 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val2")); | |
| 230 Mock::VerifyAndClearExpectations(&observer); | |
| 231 | |
| 232 // Override non-incognito value. | |
| 233 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))); | |
| 234 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val3")); | |
| 235 Mock::VerifyAndClearExpectations(&observer); | |
| 236 | |
| 237 // Disable. | |
| 238 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))); | |
| 239 epvm_.SetExtensionState(kExt1, false); | |
| 240 Mock::VerifyAndClearExpectations(&observer); | |
| 241 | |
| 242 // Enable. | |
| 243 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))); | |
| 244 epvm_.SetExtensionState(kExt1, true); | |
| 245 Mock::VerifyAndClearExpectations(&observer); | |
| 246 | |
| 247 // Uninstall | |
| 248 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))); | |
| 249 epvm_.UnregisterExtension(kExt1); | |
| 250 Mock::VerifyAndClearExpectations(&observer); | |
| 251 | |
| 252 epvm_.RemoveObserver(&observer); | |
| 253 | |
| 254 // Write new value --> no notification after removing observer. | |
| 255 EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))).Times(0); | |
| 256 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 257 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val4")); | |
| 258 Mock::VerifyAndClearExpectations(&observer); | |
| 259 } | |
| 260 | |
| 261 // Tests disabling an extension. | |
| 262 TEST_F(ExtensionPrefValueMapTest, DisableExt) { | |
| 263 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 264 | |
| 265 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 266 epvm_.SetExtensionState(kExt1, false); | |
| 267 EXPECT_EQ("", GetValue(kPref1, false)); | |
| 268 } | |
| 269 | |
| 270 // Tests disabling and reenabling an extension. | |
| 271 TEST_F(ExtensionPrefValueMapTest, ReenableExt) { | |
| 272 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 273 | |
| 274 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1")); | |
| 275 epvm_.SetExtensionState(kExt1, false); | |
| 276 epvm_.SetExtensionState(kExt1, true); | |
| 277 EXPECT_EQ("val1", GetValue(kPref1, false)); | |
| 278 } | |
| 279 | |
| 280 struct OverrideIncognitoTestCase { | |
| 281 OverrideIncognitoTestCase(int val_ext1_regular, | |
| 282 int val_ext1_regular_only, | |
| 283 int val_ext1_incognito_pers, | |
| 284 int val_ext1_incognito_sess, | |
| 285 int val_ext2_regular, | |
| 286 int val_ext2_regular_only, | |
| 287 int val_ext2_incognito_pers, | |
| 288 int val_ext2_incognito_sess, | |
| 289 int effective_value_regular, | |
| 290 int effective_value_incognito) | |
| 291 : val_ext1_regular_(val_ext1_regular), | |
| 292 val_ext1_regular_only_(val_ext1_regular_only), | |
| 293 val_ext1_incognito_pers_(val_ext1_incognito_pers), | |
| 294 val_ext1_incognito_sess_(val_ext1_incognito_sess), | |
| 295 val_ext2_regular_(val_ext2_regular), | |
| 296 val_ext2_regular_only_(val_ext2_regular_only), | |
| 297 val_ext2_incognito_pers_(val_ext2_incognito_pers), | |
| 298 val_ext2_incognito_sess_(val_ext2_incognito_sess), | |
| 299 effective_value_regular_(effective_value_regular), | |
| 300 effective_value_incognito_(effective_value_incognito) {} | |
| 301 | |
| 302 // pers. = persistent | |
| 303 // sess. = session only | |
| 304 int val_ext1_regular_; // pref value of extension 1 | |
| 305 int val_ext1_regular_only_; // pref value of extension 1 regular-only. | |
| 306 int val_ext1_incognito_pers_; // pref value of extension 1 incognito pers. | |
| 307 int val_ext1_incognito_sess_; // pref value of extension 1 incognito sess. | |
| 308 int val_ext2_regular_; // pref value of extension 2 | |
| 309 int val_ext2_regular_only_; // pref value of extension 2 regular-only. | |
| 310 int val_ext2_incognito_pers_; // pref value of extension 2 incognito pers. | |
| 311 int val_ext2_incognito_sess_; // pref value of extension 2 incognito sess. | |
| 312 int effective_value_regular_; // desired winner regular | |
| 313 int effective_value_incognito_; // desired winner incognito | |
| 314 }; | |
| 315 | |
| 316 class ExtensionPrefValueMapTestIncognitoTests | |
| 317 : public ExtensionPrefValueMapTestBase< | |
| 318 testing::TestWithParam<OverrideIncognitoTestCase> > { | |
| 319 }; | |
| 320 | |
| 321 TEST_P(ExtensionPrefValueMapTestIncognitoTests, OverrideIncognito) { | |
| 322 OverrideIncognitoTestCase test = GetParam(); | |
| 323 const char* strings[] = { | |
| 324 "undefined", | |
| 325 "val1", | |
| 326 "val2", | |
| 327 "val3", | |
| 328 "val4", | |
| 329 "val5", | |
| 330 "val6", | |
| 331 "val7", | |
| 332 "val8", | |
| 333 }; | |
| 334 | |
| 335 epvm_.RegisterExtension(kExt1, CreateTime(10), true); | |
| 336 epvm_.RegisterExtension(kExt2, CreateTime(20), true); | |
| 337 if (test.val_ext1_regular_) { | |
| 338 epvm_.SetExtensionPref(kExt1, kPref1, kRegular, | |
| 339 CreateVal(strings[test.val_ext1_regular_])); | |
| 340 } | |
| 341 if (test.val_ext1_regular_only_) { | |
| 342 epvm_.SetExtensionPref(kExt1, kPref1, kRegularOnly, | |
| 343 CreateVal(strings[test.val_ext1_regular_only_])); | |
| 344 } | |
| 345 if (test.val_ext1_incognito_pers_) { | |
| 346 epvm_.SetExtensionPref(kExt1, kPref1, kIncognitoPersistent, | |
| 347 CreateVal(strings[test.val_ext1_incognito_pers_])); | |
| 348 } | |
| 349 if (test.val_ext1_incognito_sess_) { | |
| 350 epvm_.SetExtensionPref(kExt1, kPref1, kIncognitoSessionOnly, | |
| 351 CreateVal(strings[test.val_ext1_incognito_sess_])); | |
| 352 } | |
| 353 if (test.val_ext2_regular_) { | |
| 354 epvm_.SetExtensionPref(kExt2, kPref1, kRegular, | |
| 355 CreateVal(strings[test.val_ext2_regular_])); | |
| 356 } | |
| 357 if (test.val_ext2_regular_only_) { | |
| 358 epvm_.SetExtensionPref(kExt2, kPref1, kRegularOnly, | |
| 359 CreateVal(strings[test.val_ext2_regular_only_])); | |
| 360 } | |
| 361 if (test.val_ext2_incognito_pers_) { | |
| 362 epvm_.SetExtensionPref(kExt2, kPref1, kIncognitoPersistent, | |
| 363 CreateVal(strings[test.val_ext2_incognito_pers_])); | |
| 364 } | |
| 365 if (test.val_ext2_incognito_sess_) { | |
| 366 epvm_.SetExtensionPref(kExt2, kPref1, kIncognitoSessionOnly, | |
| 367 CreateVal(strings[test.val_ext2_incognito_sess_])); | |
| 368 } | |
| 369 std::string actual; | |
| 370 EXPECT_EQ(strings[test.effective_value_regular_], GetValue(kPref1, false)); | |
| 371 EXPECT_EQ(strings[test.effective_value_incognito_], GetValue(kPref1, true)); | |
| 372 epvm_.UnregisterExtension(kExt1); | |
| 373 epvm_.UnregisterExtension(kExt2); | |
| 374 } | |
| 375 | |
| 376 INSTANTIATE_TEST_CASE_P( | |
| 377 ExtensionPrefValueMapTestIncognitoTestsInstance, | |
| 378 ExtensionPrefValueMapTestIncognitoTests, | |
| 379 testing::Values( | |
| 380 // e.g. (1, 0, 0, 0, 0, 0, 7, 0, 1, 7), means: | |
| 381 // ext1 regular is set to "val1", ext2 incognito persistent is set to | |
| 382 // "val7" | |
| 383 // --> the winning regular value is "val1", the winning incognito | |
| 384 // value is "val7". | |
| 385 OverrideIncognitoTestCase(1, 0, 0, 0, 0, 0, 0, 0, 1, 1), | |
| 386 OverrideIncognitoTestCase(1, 2, 0, 0, 0, 0, 0, 0, 2, 1), | |
| 387 OverrideIncognitoTestCase(1, 0, 3, 0, 0, 0, 0, 0, 1, 3), | |
| 388 OverrideIncognitoTestCase(1, 0, 0, 4, 0, 0, 0, 0, 1, 4), | |
| 389 OverrideIncognitoTestCase(1, 0, 3, 4, 0, 0, 0, 0, 1, 4), | |
| 390 OverrideIncognitoTestCase(1, 2, 3, 0, 0, 0, 0, 0, 2, 3), | |
| 391 OverrideIncognitoTestCase(1, 0, 0, 0, 5, 0, 0, 0, 5, 5), | |
| 392 OverrideIncognitoTestCase(1, 2, 3, 0, 5, 0, 0, 0, 5, 5), | |
| 393 OverrideIncognitoTestCase(1, 0, 0, 0, 0, 6, 0, 0, 6, 1), | |
| 394 OverrideIncognitoTestCase(1, 0, 3, 0, 5, 6, 0, 0, 6, 5), | |
| 395 OverrideIncognitoTestCase(1, 0, 0, 4, 5, 6, 0, 0, 6, 5), | |
| 396 OverrideIncognitoTestCase(1, 0, 0, 0, 0, 0, 7, 0, 1, 7), | |
| 397 OverrideIncognitoTestCase(1, 2, 0, 0, 5, 0, 7, 0, 5, 7), | |
| 398 OverrideIncognitoTestCase(1, 2, 0, 0, 5, 0, 0, 8, 5, 8), | |
| 399 OverrideIncognitoTestCase(1, 2, 0, 0, 5, 0, 7, 8, 5, 8), | |
| 400 OverrideIncognitoTestCase(1, 2, 3, 0, 0, 6, 7, 0, 6, 7))); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 46853004:
Move ExtensionPrefs and friends to extensions/ directory. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src