chrome/browser/extensions/api/storage/settings_apitest.cc

   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/bind.h"
   6 #include "base/json/json_writer.h"
   7 #include "base/memory/ref_counted.h"
   8 #include "base/run_loop.h"
   9 #include "base/values.h"
  10 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
  11 #include "chrome/browser/extensions/extension_apitest.h"
  12 #include "chrome/browser/extensions/extension_system_factory.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/ui/browser.h"
  15 #include "extensions/browser/api/storage/settings_namespace.h"
  16 #include "extensions/browser/api/storage/storage_frontend.h"
  17 #include "extensions/browser/extension_system.h"
  18 #include "extensions/common/value_builder.h"
  19 #include "extensions/test/extension_test_message_listener.h"
  20 #include "extensions/test/result_catcher.h"
  21 #include "sync/api/fake_sync_change_processor.h"
  22 #include "sync/api/sync_change.h"
  23 #include "sync/api/sync_change_processor.h"
  24 #include "sync/api/sync_change_processor_wrapper_for_test.h"
  25 #include "sync/api/sync_error_factory.h"
  26 #include "sync/api/sync_error_factory_mock.h"
  27 #include "sync/api/syncable_service.h"
  28 #include "testing/gmock/include/gmock/gmock.h"
  29
  30 #if defined(ENABLE_CONFIGURATION_POLICY)
  31 #include "chrome/browser/policy/schema_registry_service.h"
  32 #include "chrome/browser/policy/schema_registry_service_factory.h"
  33 #include "components/policy/core/browser/browser_policy_connector.h"
  34 #include "components/policy/core/common/mock_configuration_policy_provider.h"
  35 #include "components/policy/core/common/policy_bundle.h"
  36 #include "components/policy/core/common/policy_map.h"
  37 #include "components/policy/core/common/policy_namespace.h"
  38 #include "components/policy/core/common/policy_types.h"
  39 #include "components/policy/core/common/schema.h"
  40 #include "components/policy/core/common/schema_map.h"
  41 #include "components/policy/core/common/schema_registry.h"
  42 #endif
  43
  44 namespace extensions {
  45
  46 using settings_namespace::LOCAL;
  47 using settings_namespace::MANAGED;
  48 using settings_namespace::Namespace;
  49 using settings_namespace::SYNC;
  50 using settings_namespace::ToString;
  51 using testing::Mock;
  52 using testing::Return;
  53 using testing::_;
  54
  55 namespace {
  56
  57 // TODO(kalman): test both EXTENSION_SETTINGS and APP_SETTINGS.
  58 const syncer::ModelType kModelType = syncer::EXTENSION_SETTINGS;
  59
  60 // The managed_storage extension has a key defined in its manifest, so that
  61 // its extension ID is well-known and the policy system can push policies for
  62 // the extension.
  63 const char kManagedStorageExtensionId[] = "kjmkgkdkpedkejedfhmfcenooemhbpbo";
  64
  65 class MockSchemaRegistryObserver : public policy::SchemaRegistry::Observer {
  66  public:
  67   MockSchemaRegistryObserver() {}
  68   virtual ~MockSchemaRegistryObserver() {}
  69
  70   MOCK_METHOD1(OnSchemaRegistryUpdated, void(bool));
  71 };
  72
  73 }  // namespace
  74
  75 class ExtensionSettingsApiTest : public ExtensionApiTest {
  76  protected:
  77   void SetUpInProcessBrowserTestFixture() override {
  78     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
  79
  80 #if defined(ENABLE_CONFIGURATION_POLICY)
  81     EXPECT_CALL(policy_provider_, IsInitializationComplete(_))
  82         .WillRepeatedly(Return(true));
  83     policy_provider_.SetAutoRefresh();
  84     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
  85         &policy_provider_);
  86 #endif
  87   }
  88
  89   void ReplyWhenSatisfied(
  90       Namespace settings_namespace,
  91       const std::string& normal_action,
  92       const std::string& incognito_action) {
  93     MaybeLoadAndReplyWhenSatisfied(
  94         settings_namespace, normal_action, incognito_action, NULL, false);
  95   }
  96
  97   const Extension* LoadAndReplyWhenSatisfied(
  98       Namespace settings_namespace,
  99       const std::string& normal_action,
 100       const std::string& incognito_action,
 101       const std::string& extension_dir) {
 102     return MaybeLoadAndReplyWhenSatisfied(
 103         settings_namespace,
 104         normal_action,
 105         incognito_action,
 106         &extension_dir,
 107         false);
 108   }
 109
 110   void FinalReplyWhenSatisfied(
 111       Namespace settings_namespace,
 112       const std::string& normal_action,
 113       const std::string& incognito_action) {
 114     MaybeLoadAndReplyWhenSatisfied(
 115         settings_namespace, normal_action, incognito_action, NULL, true);
 116   }
 117
 118   syncer::SyncableService* GetSyncableService() {
 119     return settings_sync_util::GetSyncableService(browser()->profile(),
 120                                                   kModelType);
 121   }
 122
 123   void InitSync(syncer::SyncChangeProcessor* sync_processor) {
 124     base::MessageLoop::current()->RunUntilIdle();
 125     InitSyncWithSyncableService(sync_processor, GetSyncableService());
 126   }
 127
 128   void SendChanges(const syncer::SyncChangeList& change_list) {
 129     base::MessageLoop::current()->RunUntilIdle();
 130     SendChangesToSyncableService(change_list, GetSyncableService());
 131   }
 132
 133 #if defined(ENABLE_CONFIGURATION_POLICY)
 134   void SetPolicies(const base::DictionaryValue& policies) {
 135     scoped_ptr<policy::PolicyBundle> bundle(new policy::PolicyBundle());
 136     policy::PolicyMap& policy_map = bundle->Get(policy::PolicyNamespace(
 137         policy::POLICY_DOMAIN_EXTENSIONS, kManagedStorageExtensionId));
 138     policy_map.LoadFrom(&policies, policy::POLICY_LEVEL_MANDATORY,
 139                         policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD);
 140     policy_provider_.UpdatePolicy(bundle.Pass());
 141   }
 142 #endif
 143
 144  private:
 145   const Extension* MaybeLoadAndReplyWhenSatisfied(
 146       Namespace settings_namespace,
 147       const std::string& normal_action,
 148       const std::string& incognito_action,
 149       // May be NULL to imply not loading the extension.
 150       const std::string* extension_dir,
 151       bool is_final_action) {
 152     ExtensionTestMessageListener listener("waiting", true);
 153     ExtensionTestMessageListener listener_incognito("waiting_incognito", true);
 154
 155     // Only load the extension after the listeners have been set up, to avoid
 156     // initialisation race conditions.
 157     const Extension* extension = NULL;
 158     if (extension_dir) {
 159       extension = LoadExtensionIncognito(
 160           test_data_dir_.AppendASCII("settings").AppendASCII(*extension_dir));
 161       EXPECT_TRUE(extension);
 162     }
 163
 164     EXPECT_TRUE(listener.WaitUntilSatisfied());
 165     EXPECT_TRUE(listener_incognito.WaitUntilSatisfied());
 166
 167     listener.Reply(
 168         CreateMessage(settings_namespace, normal_action, is_final_action));
 169     listener_incognito.Reply(
 170         CreateMessage(settings_namespace, incognito_action, is_final_action));
 171     return extension;
 172   }
 173
 174   std::string CreateMessage(
 175       Namespace settings_namespace,
 176       const std::string& action,
 177       bool is_final_action) {
 178     base::DictionaryValue message;
 179     message.SetString("namespace", ToString(settings_namespace));
 180     message.SetString("action", action);
 181     message.SetBoolean("isFinalAction", is_final_action);
 182     std::string message_json;
 183     base::JSONWriter::Write(message, &message_json);
 184     return message_json;
 185   }
 186
 187   void InitSyncWithSyncableService(
 188       syncer::SyncChangeProcessor* sync_processor,
 189       syncer::SyncableService* settings_service) {
 190     EXPECT_FALSE(
 191         settings_service->MergeDataAndStartSyncing(
 192                               kModelType,
 193                               syncer::SyncDataList(),
 194                               scoped_ptr<syncer::SyncChangeProcessor>(
 195                                   new syncer::SyncChangeProcessorWrapperForTest(
 196                                       sync_processor)),
 197                               scoped_ptr<syncer::SyncErrorFactory>(
 198                                   new syncer::SyncErrorFactoryMock()))
 199             .error()
 200             .IsSet());
 201   }
 202
 203   void SendChangesToSyncableService(
 204       const syncer::SyncChangeList& change_list,
 205       syncer::SyncableService* settings_service) {
 206     EXPECT_FALSE(
 207         settings_service->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
 208   }
 209
 210  protected:
 211 #if defined(ENABLE_CONFIGURATION_POLICY)
 212   policy::MockConfigurationPolicyProvider policy_provider_;
 213 #endif
 214 };
 215
 216 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, SimpleTest) {
 217   ASSERT_TRUE(RunExtensionTest("settings/simple_test")) << message_;
 218 }
 219
 220 // Structure of this test taken from IncognitoSplitMode.
 221 // Note that only split-mode incognito is tested, because spanning mode
 222 // incognito looks the same as normal mode when the only API activity comes
 223 // from background pages.
 224 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, SplitModeIncognito) {
 225   // We need 2 ResultCatchers because we'll be running the same test in both
 226   // regular and incognito mode.
 227   ResultCatcher catcher, catcher_incognito;
 228   catcher.RestrictToBrowserContext(browser()->profile());
 229   catcher_incognito.RestrictToBrowserContext(
 230       browser()->profile()->GetOffTheRecordProfile());
 231
 232   LoadAndReplyWhenSatisfied(SYNC,
 233       "assertEmpty", "assertEmpty", "split_incognito");
 234   ReplyWhenSatisfied(SYNC, "noop", "setFoo");
 235   ReplyWhenSatisfied(SYNC, "assertFoo", "assertFoo");
 236   ReplyWhenSatisfied(SYNC, "clear", "noop");
 237   ReplyWhenSatisfied(SYNC, "assertEmpty", "assertEmpty");
 238   ReplyWhenSatisfied(SYNC, "setFoo", "noop");
 239   ReplyWhenSatisfied(SYNC, "assertFoo", "assertFoo");
 240   ReplyWhenSatisfied(SYNC, "noop", "removeFoo");
 241   FinalReplyWhenSatisfied(SYNC, "assertEmpty", "assertEmpty");
 242
 243   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 244   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 245 }
 246
 247 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
 248     OnChangedNotificationsBetweenBackgroundPages) {
 249   // We need 2 ResultCatchers because we'll be running the same test in both
 250   // regular and incognito mode.
 251   ResultCatcher catcher, catcher_incognito;
 252   catcher.RestrictToBrowserContext(browser()->profile());
 253   catcher_incognito.RestrictToBrowserContext(
 254       browser()->profile()->GetOffTheRecordProfile());
 255
 256   LoadAndReplyWhenSatisfied(SYNC,
 257       "assertNoNotifications", "assertNoNotifications", "split_incognito");
 258   ReplyWhenSatisfied(SYNC, "noop", "setFoo");
 259   ReplyWhenSatisfied(SYNC,
 260       "assertAddFooNotification", "assertAddFooNotification");
 261   ReplyWhenSatisfied(SYNC, "clearNotifications", "clearNotifications");
 262   ReplyWhenSatisfied(SYNC, "removeFoo", "noop");
 263   FinalReplyWhenSatisfied(SYNC,
 264       "assertDeleteFooNotification", "assertDeleteFooNotification");
 265
 266   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 267   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 268 }
 269
 270 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
 271     SyncAndLocalAreasAreSeparate) {
 272   // We need 2 ResultCatchers because we'll be running the same test in both
 273   // regular and incognito mode.
 274   ResultCatcher catcher, catcher_incognito;
 275   catcher.RestrictToBrowserContext(browser()->profile());
 276   catcher_incognito.RestrictToBrowserContext(
 277       browser()->profile()->GetOffTheRecordProfile());
 278
 279   LoadAndReplyWhenSatisfied(SYNC,
 280       "assertNoNotifications", "assertNoNotifications", "split_incognito");
 281
 282   ReplyWhenSatisfied(SYNC, "noop", "setFoo");
 283   ReplyWhenSatisfied(SYNC, "assertFoo", "assertFoo");
 284   ReplyWhenSatisfied(SYNC,
 285       "assertAddFooNotification", "assertAddFooNotification");
 286   ReplyWhenSatisfied(LOCAL, "assertEmpty", "assertEmpty");
 287   ReplyWhenSatisfied(LOCAL, "assertNoNotifications", "assertNoNotifications");
 288
 289   ReplyWhenSatisfied(SYNC, "clearNotifications", "clearNotifications");
 290
 291   ReplyWhenSatisfied(LOCAL, "setFoo", "noop");
 292   ReplyWhenSatisfied(LOCAL, "assertFoo", "assertFoo");
 293   ReplyWhenSatisfied(LOCAL,
 294       "assertAddFooNotification", "assertAddFooNotification");
 295   ReplyWhenSatisfied(SYNC, "assertFoo", "assertFoo");
 296   ReplyWhenSatisfied(SYNC, "assertNoNotifications", "assertNoNotifications");
 297
 298   ReplyWhenSatisfied(LOCAL, "clearNotifications", "clearNotifications");
 299
 300   ReplyWhenSatisfied(LOCAL, "noop", "removeFoo");
 301   ReplyWhenSatisfied(LOCAL, "assertEmpty", "assertEmpty");
 302   ReplyWhenSatisfied(LOCAL,
 303       "assertDeleteFooNotification", "assertDeleteFooNotification");
 304   ReplyWhenSatisfied(SYNC, "assertFoo", "assertFoo");
 305   ReplyWhenSatisfied(SYNC, "assertNoNotifications", "assertNoNotifications");
 306
 307   ReplyWhenSatisfied(LOCAL, "clearNotifications", "clearNotifications");
 308
 309   ReplyWhenSatisfied(SYNC, "removeFoo", "noop");
 310   ReplyWhenSatisfied(SYNC, "assertEmpty", "assertEmpty");
 311   ReplyWhenSatisfied(SYNC,
 312       "assertDeleteFooNotification", "assertDeleteFooNotification");
 313   ReplyWhenSatisfied(LOCAL, "assertNoNotifications", "assertNoNotifications");
 314   FinalReplyWhenSatisfied(LOCAL, "assertEmpty", "assertEmpty");
 315
 316   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 317   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 318 }
 319
 320 // Disabled, see crbug.com/101110
 321 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
 322     DISABLED_OnChangedNotificationsFromSync) {
 323   // We need 2 ResultCatchers because we'll be running the same test in both
 324   // regular and incognito mode.
 325   ResultCatcher catcher, catcher_incognito;
 326   catcher.RestrictToBrowserContext(browser()->profile());
 327   catcher_incognito.RestrictToBrowserContext(
 328       browser()->profile()->GetOffTheRecordProfile());
 329
 330   const Extension* extension =
 331       LoadAndReplyWhenSatisfied(SYNC,
 332           "assertNoNotifications", "assertNoNotifications", "split_incognito");
 333   const std::string& extension_id = extension->id();
 334
 335   syncer::FakeSyncChangeProcessor sync_processor;
 336   InitSync(&sync_processor);
 337
 338   // Set "foo" to "bar" via sync.
 339   syncer::SyncChangeList sync_changes;
 340   base::StringValue bar("bar");
 341   sync_changes.push_back(settings_sync_util::CreateAdd(
 342       extension_id, "foo", bar, kModelType));
 343   SendChanges(sync_changes);
 344
 345   ReplyWhenSatisfied(SYNC,
 346       "assertAddFooNotification", "assertAddFooNotification");
 347   ReplyWhenSatisfied(SYNC, "clearNotifications", "clearNotifications");
 348
 349   // Remove "foo" via sync.
 350   sync_changes.clear();
 351   sync_changes.push_back(settings_sync_util::CreateDelete(
 352       extension_id, "foo", kModelType));
 353   SendChanges(sync_changes);
 354
 355   FinalReplyWhenSatisfied(SYNC,
 356       "assertDeleteFooNotification", "assertDeleteFooNotification");
 357
 358   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 359   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 360 }
 361
 362 // Disabled, see crbug.com/101110
 363 //
 364 // TODO: boring test, already done in the unit tests.  What we really should be
 365 // be testing is that the areas don't overlap.
 366 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
 367     DISABLED_OnChangedNotificationsFromSyncNotSentToLocal) {
 368   // We need 2 ResultCatchers because we'll be running the same test in both
 369   // regular and incognito mode.
 370   ResultCatcher catcher, catcher_incognito;
 371   catcher.RestrictToBrowserContext(browser()->profile());
 372   catcher_incognito.RestrictToBrowserContext(
 373       browser()->profile()->GetOffTheRecordProfile());
 374
 375   const Extension* extension =
 376       LoadAndReplyWhenSatisfied(LOCAL,
 377           "assertNoNotifications", "assertNoNotifications", "split_incognito");
 378   const std::string& extension_id = extension->id();
 379
 380   syncer::FakeSyncChangeProcessor sync_processor;
 381   InitSync(&sync_processor);
 382
 383   // Set "foo" to "bar" via sync.
 384   syncer::SyncChangeList sync_changes;
 385   base::StringValue bar("bar");
 386   sync_changes.push_back(settings_sync_util::CreateAdd(
 387       extension_id, "foo", bar, kModelType));
 388   SendChanges(sync_changes);
 389
 390   ReplyWhenSatisfied(LOCAL, "assertNoNotifications", "assertNoNotifications");
 391
 392   // Remove "foo" via sync.
 393   sync_changes.clear();
 394   sync_changes.push_back(settings_sync_util::CreateDelete(
 395       extension_id, "foo", kModelType));
 396   SendChanges(sync_changes);
 397
 398   FinalReplyWhenSatisfied(LOCAL,
 399       "assertNoNotifications", "assertNoNotifications");
 400
 401   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 402   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 403 }
 404
 405 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, IsStorageEnabled) {
 406   StorageFrontend* frontend = StorageFrontend::Get(browser()->profile());
 407   EXPECT_TRUE(frontend->IsStorageEnabled(LOCAL));
 408   EXPECT_TRUE(frontend->IsStorageEnabled(SYNC));
 409
 410 #if defined(ENABLE_CONFIGURATION_POLICY)
 411   EXPECT_TRUE(frontend->IsStorageEnabled(MANAGED));
 412 #else
 413   EXPECT_FALSE(frontend->IsStorageEnabled(MANAGED));
 414 #endif
 415 }
 416
 417 #if defined(ENABLE_CONFIGURATION_POLICY)
 418
 419 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ExtensionsSchemas) {
 420   // Verifies that the Schemas for the extensions domain are created on startup.
 421   Profile* profile = browser()->profile();
 422   ExtensionSystem* extension_system = ExtensionSystem::Get(profile);
 423   if (!extension_system->ready().is_signaled()) {
 424     // Wait until the extension system is ready.
 425     base::RunLoop run_loop;
 426     extension_system->ready().Post(FROM_HERE, run_loop.QuitClosure());
 427     run_loop.Run();
 428     ASSERT_TRUE(extension_system->ready().is_signaled());
 429   }
 430
 431   // This test starts without any test extensions installed.
 432   EXPECT_FALSE(GetSingleLoadedExtension());
 433   message_.clear();
 434
 435   policy::SchemaRegistry* registry =
 436       policy::SchemaRegistryServiceFactory::GetForContext(profile)->registry();
 437   ASSERT_TRUE(registry);
 438   EXPECT_FALSE(registry->schema_map()->GetSchema(policy::PolicyNamespace(
 439       policy::POLICY_DOMAIN_EXTENSIONS, kManagedStorageExtensionId)));
 440
 441   MockSchemaRegistryObserver observer;
 442   registry->AddObserver(&observer);
 443
 444   // Install a managed extension.
 445   EXPECT_CALL(observer, OnSchemaRegistryUpdated(true));
 446   const Extension* extension =
 447       LoadExtension(test_data_dir_.AppendASCII("settings/managed_storage"));
 448   ASSERT_TRUE(extension);
 449   Mock::VerifyAndClearExpectations(&observer);
 450   registry->RemoveObserver(&observer);
 451
 452   // Verify that its schema has been published, and verify its contents.
 453   const policy::Schema* schema =
 454       registry->schema_map()->GetSchema(policy::PolicyNamespace(
 455           policy::POLICY_DOMAIN_EXTENSIONS, kManagedStorageExtensionId));
 456   ASSERT_TRUE(schema);
 457
 458   ASSERT_TRUE(schema->valid());
 459   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema->type());
 460   ASSERT_TRUE(schema->GetKnownProperty("string-policy").valid());
 461   EXPECT_EQ(base::Value::TYPE_STRING,
 462             schema->GetKnownProperty("string-policy").type());
 463   ASSERT_TRUE(schema->GetKnownProperty("int-policy").valid());
 464   EXPECT_EQ(base::Value::TYPE_INTEGER,
 465             schema->GetKnownProperty("int-policy").type());
 466   ASSERT_TRUE(schema->GetKnownProperty("double-policy").valid());
 467   EXPECT_EQ(base::Value::TYPE_DOUBLE,
 468             schema->GetKnownProperty("double-policy").type());
 469   ASSERT_TRUE(schema->GetKnownProperty("boolean-policy").valid());
 470   EXPECT_EQ(base::Value::TYPE_BOOLEAN,
 471             schema->GetKnownProperty("boolean-policy").type());
 472
 473   policy::Schema list = schema->GetKnownProperty("list-policy");
 474   ASSERT_TRUE(list.valid());
 475   ASSERT_EQ(base::Value::TYPE_LIST, list.type());
 476   ASSERT_TRUE(list.GetItems().valid());
 477   EXPECT_EQ(base::Value::TYPE_STRING, list.GetItems().type());
 478
 479   policy::Schema dict = schema->GetKnownProperty("dict-policy");
 480   ASSERT_TRUE(dict.valid());
 481   ASSERT_EQ(base::Value::TYPE_DICTIONARY, dict.type());
 482   list = dict.GetKnownProperty("list");
 483   ASSERT_TRUE(list.valid());
 484   ASSERT_EQ(base::Value::TYPE_LIST, list.type());
 485   dict = list.GetItems();
 486   ASSERT_TRUE(dict.valid());
 487   ASSERT_EQ(base::Value::TYPE_DICTIONARY, dict.type());
 488   ASSERT_TRUE(dict.GetProperty("anything").valid());
 489   EXPECT_EQ(base::Value::TYPE_INTEGER, dict.GetProperty("anything").type());
 490 }
 491
 492 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ManagedStorage) {
 493   // Set policies for the test extension.
 494   scoped_ptr<base::DictionaryValue> policy = extensions::DictionaryBuilder()
 495       .Set("string-policy", "value")
 496       .Set("int-policy", -123)
 497       .Set("double-policy", 456e7)
 498       .SetBoolean("boolean-policy", true)
 499       .Set("list-policy", extensions::ListBuilder()
 500           .Append("one")
 501           .Append("two")
 502           .Append("three"))
 503       .Set("dict-policy", extensions::DictionaryBuilder()
 504           .Set("list", extensions::ListBuilder()
 505               .Append(extensions::DictionaryBuilder()
 506                   .Set("one", 1)
 507                   .Set("two", 2))
 508               .Append(extensions::DictionaryBuilder()
 509                   .Set("three", 3))))
 510       .Build();
 511   SetPolicies(*policy);
 512   // Now run the extension.
 513   ASSERT_TRUE(RunExtensionTest("settings/managed_storage")) << message_;
 514 }
 515
 516 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
 517                        DISABLED_PRE_ManagedStorageEvents) {
 518   ResultCatcher catcher;
 519
 520   // This test starts without any test extensions installed.
 521   EXPECT_FALSE(GetSingleLoadedExtension());
 522   message_.clear();
 523
 524   // Set policies for the test extension.
 525   scoped_ptr<base::DictionaryValue> policy = extensions::DictionaryBuilder()
 526       .Set("constant-policy", "aaa")
 527       .Set("changes-policy", "bbb")
 528       .Set("deleted-policy", "ccc")
 529       .Build();
 530   SetPolicies(*policy);
 531
 532   ExtensionTestMessageListener ready_listener("ready", false);
 533   // Load the extension to install the event listener.
 534   const Extension* extension = LoadExtension(
 535       test_data_dir_.AppendASCII("settings/managed_storage_events"));
 536   ASSERT_TRUE(extension);
 537   // Wait until the extension sends the "ready" message.
 538   ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
 539
 540   // Now change the policies and wait until the extension is done.
 541   policy = extensions::DictionaryBuilder()
 542       .Set("constant-policy", "aaa")
 543       .Set("changes-policy", "ddd")
 544       .Set("new-policy", "eee")
 545       .Build();
 546   SetPolicies(*policy);
 547   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 548 }
 549
 550 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
 551                        DISABLED_ManagedStorageEvents) {
 552   // This test runs after PRE_ManagedStorageEvents without having deleted the
 553   // profile, so the extension is still around. While the browser restarted the
 554   // policy went back to the empty default, and so the extension should receive
 555   // the corresponding change events.
 556
 557   ResultCatcher catcher;
 558
 559   // Verify that the test extension is still installed.
 560   const Extension* extension = GetSingleLoadedExtension();
 561   ASSERT_TRUE(extension);
 562   EXPECT_EQ(kManagedStorageExtensionId, extension->id());
 563
 564   // Running the test again skips the onInstalled callback, and just triggers
 565   // the onChanged notification.
 566   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 567 }
 568
 569 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
 570
 571 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ManagedStorageDisabled) {
 572   // Disable the 'managed' namespace. This is redundant when
 573   // ENABLE_CONFIGURATION_POLICY is not defined.
 574   StorageFrontend* frontend = StorageFrontend::Get(browser()->profile());
 575   frontend->DisableStorageForTesting(MANAGED);
 576   EXPECT_FALSE(frontend->IsStorageEnabled(MANAGED));
 577   // Now run the extension.
 578   ASSERT_TRUE(RunExtensionTest("settings/managed_storage_disabled"))
 579       << message_;
 580 }
 581
 582 }  // namespace extensions