Policy providers all get a SchemaRegistry to work with.

chrome/browser/policy/browser_policy_connector.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 "chrome/browser/policy/browser_policy_connector.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/async_policy_provider.h"
 #include "chrome/browser/policy/cloud/cloud_policy_client.h"
 #include "chrome/browser/policy/cloud/cloud_policy_refresh_scheduler.h"
 #include "chrome/browser/policy/cloud/cloud_policy_service.h"
 #include "chrome/browser/policy/cloud/device_management_service.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
-#include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/browser/policy/policy_service_impl.h"
 #include "chrome/browser/policy/policy_statistics_collector.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/policy/core/common/policy_pref_names.h"
 #include "components/policy/core/common/schema.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_client.h"
@@ skipping 234 matching lines @@
   request_context_ = request_context;
 
   scoped_ptr<DeviceManagementService::Configuration> configuration(
       new DeviceManagementServiceConfiguration);
   device_management_service_.reset(
       new DeviceManagementService(configuration.Pass(), request_context));
   device_management_service_->ScheduleInitialization(
       kServiceInitializationStartupDelay);
 
   if (g_testing_provider)
-    g_testing_provider->Init();
+    g_testing_provider->Init(GetSchemaRegistry());
   if (platform_provider_)
-    platform_provider_->Init();
+    platform_provider_->Init(GetSchemaRegistry());
 
 #if defined(OS_CHROMEOS)
-  global_user_cloud_policy_provider_.Init();
+  global_user_cloud_policy_provider_.Init(GetSchemaRegistry());
 
   if (device_cloud_policy_manager_) {
-    device_cloud_policy_manager_->Init();
+    // For now the |device_cloud_policy_manager_| is using the global schema
+    // registry. Eventually it will have its own registry, once device cloud
+    // policy for extensions is introduced.
+    device_cloud_policy_manager_->Init(GetSchemaRegistry());
     scoped_ptr<CloudPolicyClient::StatusProvider> status_provider(
         new DeviceStatusCollector(
             local_state_,
             chromeos::system::StatisticsProvider::GetInstance(),
             NULL));
     device_cloud_policy_manager_->Connect(
         local_state_,
         device_management_service_.get(),
         status_provider.Pass());
   }
@@ skipping 117 matching lines @@
     // |providers| in decreasing order of priority.
     if (platform_provider_)
       providers.push_back(platform_provider_.get());
 #if defined(OS_CHROMEOS)
     if (device_cloud_policy_manager_)
       providers.push_back(device_cloud_policy_manager_.get());
 #endif
     std::copy(additional_providers.begin(), additional_providers.end(),
               std::back_inserter(providers));
   }
-  scoped_ptr<PolicyService> service(new PolicyServiceImpl(providers));
-  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
-      POLICY_DOMAIN_CHROME);
-  descriptor->RegisterComponent("", Schema::Wrap(GetChromeSchemaData()));
-  service->RegisterPolicyDomain(descriptor);
-  return service.Pass();
+  return scoped_ptr<PolicyService>(new PolicyServiceImpl(providers));
 }
 
 const ConfigurationPolicyHandlerList*
     BrowserPolicyConnector::GetHandlerList() const {
   return handler_list_.get();
 }
 
 UserAffiliation BrowserPolicyConnector::GetUserAffiliation(
     const std::string& user_name) {
 #if defined(OS_CHROMEOS)
@@ skipping 122 matching lines @@
   std::string timezone;
   if (chromeos::CrosSettings::Get()->GetString(chromeos::kSystemTimezonePolicy,
                                                &timezone) &&
       !timezone.empty()) {
     chromeos::system::TimezoneSettings::GetInstance()->SetTimezoneFromID(
         UTF8ToUTF16(timezone));
   }
 #endif
 }
 
-// static
 ConfigurationPolicyProvider* BrowserPolicyConnector::CreatePlatformProvider() {
 #if defined(OS_WIN)
   const PolicyDefinitionList* policy_list = GetChromePolicyDefinitionList();
   scoped_ptr<AsyncPolicyLoader> loader(PolicyLoaderWin::Create(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       policy_list));
-  return new AsyncPolicyProvider(loader.Pass());
+  return new AsyncPolicyProvider(GetSchemaRegistry(), loader.Pass());
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   const PolicyDefinitionList* policy_list = GetChromePolicyDefinitionList();
   scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderMac(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       policy_list,
       GetManagedPolicyPath(),
       new MacPreferences()));
-  return new AsyncPolicyProvider(loader.Pass());
+  return new AsyncPolicyProvider(GetSchemaRegistry(), loader.Pass());
 #elif defined(OS_POSIX) && !defined(OS_ANDROID)
   base::FilePath config_dir_path;
   if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
     scoped_ptr<AsyncPolicyLoader> loader(new ConfigDirPolicyLoader(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
         config_dir_path,
         POLICY_SCOPE_MACHINE));
-    return new AsyncPolicyProvider(loader.Pass());
+    return new AsyncPolicyProvider(GetSchemaRegistry(), loader.Pass());
   } else {
     return NULL;
   }
 #else
   return NULL;
 #endif
 }
 
 }  // namespace policy