Policy providers all get a SchemaRegistry to work with.

chrome/browser/policy/cloud/component_cloud_policy_service_unittest.cc

 // Copyright (c) 2013 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 "chrome/browser/policy/cloud/component_cloud_policy_service.h"
 
 #include "base/callback.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/sha1.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_client.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/policy_builder.h"
 #include "chrome/browser/policy/cloud/resource_cache.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
-#include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/policy_types.h"
 #include "chrome/browser/policy/proto/cloud/chrome_extension_policy.pb.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
+#include "chrome/browser/policy/schema_registry.h"
 #include "components/policy/core/common/schema.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace em = enterprise_management;
 
@@ skipping 161 matching lines @@
   base::MessageLoop loop_;
   base::ScopedTempDir temp_dir_;
   scoped_refptr<TestURLRequestContextGetter> request_context_;
   net::TestURLFetcherFactory fetcher_factory_;
   MockComponentCloudPolicyDelegate delegate_;
   // |cache_| is owned by the |service_| and is invalid once the |service_|
   // is destroyed.
   ResourceCache* cache_;
   MockCloudPolicyClient client_;
   MockCloudPolicyStore store_;
+  SchemaRegistry registry_;
   scoped_ptr<ComponentCloudPolicyService> service_;
   ComponentPolicyBuilder builder_;
   PolicyMap expected_policy_;
 };
 
 TEST_F(ComponentCloudPolicyServiceTest, InitializeWithoutCredentials) {
   EXPECT_FALSE(service_->is_initialized());
   // Run the background task to initialize the backend.
   RunUntilIdle();
   // Still waiting for the |store_|.
@@ skipping 42 matching lines @@
   std::map<std::string, std::string> contents;
   cache_->LoadAllSubkeys(ComponentCloudPolicyService::kComponentNamespaceCache,
                          &contents);
   ASSERT_EQ(1u, contents.size());
   EXPECT_EQ(std::string(dm_protocol::kChromeExtensionPolicyType),
             contents.begin()->first);
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, ConnectAfterRegister) {
   // Add some components.
-  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
-      POLICY_DOMAIN_EXTENSIONS);
-  descriptor->RegisterComponent(kTestExtension, CreateTestSchema());
-  descriptor->RegisterComponent(kTestExtension2, CreateTestSchema());
-  service_->RegisterPolicyDomain(descriptor);
+  registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension),
+      CreateTestSchema());
+  registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension2),
+      CreateTestSchema());
+  service_->OnSchemasUpdated(registry_.schema_map());
 
   // Now connect the client.
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
   service_->Connect(&client_, request_context_);
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
 
   // It receives the namespaces once the backend is initialized.
   LoadStore();
   std::set<PolicyNamespaceKey> set;
   set.insert(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
@@ skipping 27 matching lines @@
   expected_components.insert(kTestExtension2);
 
   EXPECT_EQ(expected_components, unpickled);
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, StoreReadyAfterConnectAndRegister) {
   // Add some previous data to the cache.
   PopulateCache();
 
   // Add some components.
-  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
-      POLICY_DOMAIN_EXTENSIONS);
-  descriptor->RegisterComponent(kTestExtension, CreateTestSchema());
-  service_->RegisterPolicyDomain(descriptor);
+  registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension),
+      CreateTestSchema());
+  service_->OnSchemasUpdated(registry_.schema_map());
 
   // And connect the client. Make the client have some policies, with a new
   // download_url.
   builder_.payload().set_download_url(kTestDownload2);
   client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                        kTestExtension),
                     *CreateResponse());
   service_->Connect(&client_, request_context_);
 
   // Now make the store ready.
@@ skipping 15 matching lines @@
   EXPECT_EQ(GURL(kTestDownload2), fetcher->GetOriginalURL());
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, ConnectThenRegisterThenStoreReady) {
   // Connect right after creating the service.
   service_->Connect(&client_, request_context_);
 
   // Now register the current components, before the backend has been
   // initialized.
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
-  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
-      POLICY_DOMAIN_EXTENSIONS);
-  descriptor->RegisterComponent(kTestExtension, CreateTestSchema());
-  service_->RegisterPolicyDomain(descriptor);
+  registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension),
+      CreateTestSchema());
+  service_->OnSchemasUpdated(registry_.schema_map());
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
 
   // Now load the store. The client gets the namespaces.
   LoadStore();
   std::set<PolicyNamespaceKey> set;
   set.insert(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                 kTestExtension));
   EXPECT_EQ(set, client_.namespaces_to_fetch_);
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, FetchPolicy) {
   // Initialize the store and create the backend, and connect the client.
   LoadStore();
   // A refresh is not needed, because no components were found.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyRefreshNeeded()).Times(0);
   service_->Connect(&client_, request_context_);
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // Register the components to fetch.
-  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
-      POLICY_DOMAIN_EXTENSIONS);
-  descriptor->RegisterComponent(kTestExtension, CreateTestSchema());
+  registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension),
+      CreateTestSchema());
   EXPECT_CALL(delegate_, OnComponentCloudPolicyRefreshNeeded());
-  service_->RegisterPolicyDomain(descriptor);
+  service_->OnSchemasUpdated(registry_.schema_map());
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // Send back a fake policy fetch response.
   client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                        kTestExtension),
                     *CreateResponse());
   service_->OnPolicyFetched(&client_);
   RunUntilIdle();
 
   // That should have triggered the download fetch.
@@ skipping 30 matching lines @@
   PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, kTestExtension);
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   ns.component_id = kTestExtension2;
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 
   // Now purge one of the extensions.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   // The service will start updating the components that are registered, which
   // starts by fetching policy for them.
-  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
-      POLICY_DOMAIN_EXTENSIONS);
-  descriptor->RegisterComponent(kTestExtension2, CreateTestSchema());
-  service_->RegisterPolicyDomain(descriptor);
+  registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension2),
+      CreateTestSchema());
+  service_->OnSchemasUpdated(registry_.schema_map());
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&delegate_);
 
   ns.component_id = kTestExtension;
   expected_bundle.Get(ns).Clear();
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 
   std::map<std::string, std::string> contents;
   cache_->LoadAllSubkeys("extension-policy", &contents);
   EXPECT_EQ(1u, contents.size());
@@ skipping 10 matching lines @@
   store_.policy_.reset(new em::PolicyData());  //  No credentials.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   store_.NotifyStoreLoaded();
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_TRUE(service_->is_initialized());
 
   // Connect the client and register an extension.
   service_->Connect(&client_, request_context_);
   EXPECT_CALL(delegate_, OnComponentCloudPolicyRefreshNeeded());
-  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
-      POLICY_DOMAIN_EXTENSIONS);
-  descriptor->RegisterComponent(kTestExtension, CreateTestSchema());
-  service_->RegisterPolicyDomain(descriptor);
+  registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension),
+      CreateTestSchema());
+  service_->OnSchemasUpdated(registry_.schema_map());
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // Send the response to the service. The response data will be rejected,
   // because the store doesn't have the updated credentials yet.
   client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                        kTestExtension),
                     *CreateResponse());
   service_->OnPolicyFetched(&client_);
   RunUntilIdle();
 
@@ skipping 23 matching lines @@
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // The policy is now being served.
   PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, kTestExtension);
   PolicyBundle expected_bundle;
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 }
 
 }  // namespace policy