Policy providers all get a SchemaRegistry to work with.

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

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
+#include "base/values.h"
 #include "chrome/browser/extensions/api/storage/settings_frontend.h"
 #include "chrome/browser/extensions/api/storage/settings_namespace.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "extensions/common/value_builder.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_bundle.h"
-#include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/browser/policy/policy_map.h"
-#include "chrome/browser/policy/policy_service.h"
-#include "chrome/browser/policy/profile_policy_connector.h"
-#include "chrome/browser/policy/profile_policy_connector_factory.h"
+#include "chrome/browser/policy/schema_map.h"
+#include "chrome/browser/policy/schema_registry.h"
+#include "chrome/browser/policy/schema_registry_service.h"
+#include "chrome/browser/policy/schema_registry_service_factory.h"
+#include "components/policy/core/common/policy_namespace.h"
+#include "components/policy/core/common/schema.h"
 #endif
 
 namespace extensions {
 
-using settings_namespace::FromString;
 using settings_namespace::LOCAL;
 using settings_namespace::MANAGED;
 using settings_namespace::Namespace;
 using settings_namespace::SYNC;
 using settings_namespace::ToString;
-using testing::AnyNumber;
+using testing::Mock;
 using testing::Return;
 using testing::_;
 
 namespace {
 
 // TODO(kalman): test both EXTENSION_SETTINGS and APP_SETTINGS.
 const syncer::ModelType kModelType = syncer::EXTENSION_SETTINGS;
 
 // The managed_storage extension has a key defined in its manifest, so that
 // its extension ID is well-known and the policy system can push policies for
@@ skipping 36 matching lines @@
     return recipient_->GetAllSyncData(type);
   }
 
  private:
   // The recipient of all sync changes.
   syncer::SyncChangeProcessor* recipient_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncChangeProcessorDelegate);
 };
 
+class MockSchemaRegistryObserver : public policy::SchemaRegistry::Observer {
+ public:
+  MockSchemaRegistryObserver() {}
+  virtual ~MockSchemaRegistryObserver() {}
+
+  MOCK_METHOD1(OnSchemaRegistryUpdated, void(bool));
+};
+
 }  // namespace
 
 class ExtensionSettingsApiTest : public ExtensionApiTest {
  protected:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
     EXPECT_CALL(policy_provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
-    EXPECT_CALL(policy_provider_, RegisterPolicyDomain(_)).Times(AnyNumber());
     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
         &policy_provider_);
 #endif
   }
 
   void ReplyWhenSatisfied(
       Namespace settings_namespace,
       const std::string& normal_action,
       const std::string& incognito_action) {
     MaybeLoadAndReplyWhenSatisfied(
@@ skipping 314 matching lines @@
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
   EXPECT_TRUE(frontend->IsStorageEnabled(MANAGED));
 #else
   EXPECT_FALSE(frontend->IsStorageEnabled(MANAGED));
 #endif
 }
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 
-IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, PolicyDomainDescriptor) {
-  // Verifies that the PolicyDomainDescriptor for the extensions domain is
-  // created on startup.
+IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ExtensionsSchemas) {
+  // Verifies that the Schemas for the extensions domain are created on startup.
   Profile* profile = browser()->profile();
   ExtensionSystem* extension_system =
       ExtensionSystemFactory::GetForProfile(profile);
   if (!extension_system->ready().is_signaled()) {
     // Wait until the extension system is ready.
     base::RunLoop run_loop;
     extension_system->ready().Post(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
     ASSERT_TRUE(extension_system->ready().is_signaled());
   }
 
-  policy::ProfilePolicyConnector* connector =
-      policy::ProfilePolicyConnectorFactory::GetForProfile(profile);
-  policy::PolicyService* service = connector->policy_service();
-  scoped_refptr<const policy::PolicyDomainDescriptor> descriptor =
-      service->GetPolicyDomainDescriptor(policy::POLICY_DOMAIN_EXTENSIONS);
-  EXPECT_TRUE(descriptor.get());
+  // This test starts without any test extensions installed.
+  EXPECT_FALSE(GetSingleLoadedExtension());
+  message_.clear();
+
+  policy::SchemaRegistry* registry =
+      policy::SchemaRegistryServiceFactory::GetForContext(profile);
+  ASSERT_TRUE(registry);
+  EXPECT_FALSE(registry->schema_map()->GetSchema(policy::PolicyNamespace(
+      policy::POLICY_DOMAIN_EXTENSIONS, kManagedStorageExtensionId)));
+
+  MockSchemaRegistryObserver observer;
+  registry->AddObserver(&observer);
+
+  // Install a managed extension.
+  EXPECT_CALL(observer, OnSchemaRegistryUpdated(true));
+  const Extension* extension =
+      LoadExtension(test_data_dir_.AppendASCII("settings/managed_storage"));
+  ASSERT_TRUE(extension);
+  Mock::VerifyAndClearExpectations(&observer);
+  registry->RemoveObserver(&observer);
+
+  // Verify that its schema has been published, and verify its contents.
+  const policy::Schema* schema =
+      registry->schema_map()->GetSchema(policy::PolicyNamespace(
+          policy::POLICY_DOMAIN_EXTENSIONS, kManagedStorageExtensionId));
+  ASSERT_TRUE(schema);
+
+  ASSERT_TRUE(schema->valid());
+  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema->type());
+  ASSERT_TRUE(schema->GetKnownProperty("string-policy").valid());
+  EXPECT_EQ(base::Value::TYPE_STRING,
+            schema->GetKnownProperty("string-policy").type());
+  ASSERT_TRUE(schema->GetKnownProperty("int-policy").valid());
+  EXPECT_EQ(base::Value::TYPE_INTEGER,
+            schema->GetKnownProperty("int-policy").type());
+  ASSERT_TRUE(schema->GetKnownProperty("double-policy").valid());
+  EXPECT_EQ(base::Value::TYPE_DOUBLE,
+            schema->GetKnownProperty("double-policy").type());
+  ASSERT_TRUE(schema->GetKnownProperty("boolean-policy").valid());
+  EXPECT_EQ(base::Value::TYPE_BOOLEAN,
+            schema->GetKnownProperty("boolean-policy").type());
+
+  policy::Schema list = schema->GetKnownProperty("list-policy");
+  ASSERT_TRUE(list.valid());
+  ASSERT_EQ(base::Value::TYPE_LIST, list.type());
+  ASSERT_TRUE(list.GetItems().valid());
+  EXPECT_EQ(base::Value::TYPE_STRING, list.GetItems().type());
+
+  policy::Schema dict = schema->GetKnownProperty("dict-policy");
+  ASSERT_TRUE(dict.valid());
+  ASSERT_EQ(base::Value::TYPE_DICTIONARY, dict.type());
+  list = dict.GetKnownProperty("list");
+  ASSERT_TRUE(list.valid());
+  ASSERT_EQ(base::Value::TYPE_LIST, list.type());
+  dict = list.GetItems();
+  ASSERT_TRUE(dict.valid());
+  ASSERT_EQ(base::Value::TYPE_DICTIONARY, dict.type());
+  ASSERT_TRUE(dict.GetProperty("anything").valid());
+  EXPECT_EQ(base::Value::TYPE_INTEGER, dict.GetProperty("anything").type());
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ManagedStorage) {
   // Set policies for the test extension.
   scoped_ptr<base::DictionaryValue> policy = extensions::DictionaryBuilder()
       .Set("string-policy", "value")
       .Set("int-policy", -123)
       .Set("double-policy", 456e7)
       .SetBoolean("boolean-policy", true)
       .Set("list-policy", extensions::ListBuilder()
@@ skipping 80 matching lines @@
   SettingsFrontend* frontend =
       browser()->profile()->GetExtensionService()->settings_frontend();
   frontend->DisableStorageForTesting(MANAGED);
   EXPECT_FALSE(frontend->IsStorageEnabled(MANAGED));
   // Now run the extension.
   ASSERT_TRUE(RunExtensionTest("settings/managed_storage_disabled"))
       << message_;
 }
 
 }  // namespace extensions