policy: load JSON schema into domain descriptor at start time.

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 16 matching lines @@
 #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/managed_mode_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/pref_names.h"
+#include "components/policy/core/common/policy_schema.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "grit/generated_resources.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "policy/policy_constants.h"
 #include "third_party/icu/source/i18n/unicode/regex.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/policy/policy_loader_win.h"
@@ skipping 40 matching lines @@
 // Delay in milliseconds from startup.
 const int64 kServiceInitializationStartupDelay = 5000;
 
 // The URL for the device management server.
 const char kDefaultDeviceManagementServerUrl[] =
     "https://m.google.com/devicemanagement/data/api";
 
 // Used in BrowserPolicyConnector::SetPolicyProviderForTesting.
 ConfigurationPolicyProvider* g_testing_provider = NULL;
 
-
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 base::FilePath GetManagedPolicyPath() {
   // This constructs the path to the plist file in which Mac OS X stores the
   // managed preference for the application. This is undocumented and therefore
   // fragile, but if it doesn't work out, AsyncPolicyLoader has a task that
   // polls periodically in order to reload managed preferences later even if we
   // missed the change.
   base::FilePath path;
   if (!PathService::Get(chrome::DIR_MANAGED_PREFS, &path))
     return base::FilePath();
@@ skipping 44 matching lines @@
     scoped_ptr<DeviceCloudPolicyStoreChromeOS> device_cloud_policy_store(
         new DeviceCloudPolicyStoreChromeOS(
             chromeos::DeviceSettingsService::Get(),
             install_attributes_.get()));
     device_cloud_policy_manager_.reset(
         new DeviceCloudPolicyManagerChromeOS(
             device_cloud_policy_store.Pass(),
             install_attributes_.get()));
   }
 #endif
+
+  std::vector<ConfigurationPolicyProvider*> providers;
+#if defined(OS_CHROMEOS)
+  providers.push_back(&global_user_cloud_policy_provider_);
+#endif
+  policy_service_ = CreatePolicyService(providers);
+  platform_provider_->InitialLoad();
 }
 
 BrowserPolicyConnector::~BrowserPolicyConnector() {
   if (is_initialized()) {
     // Shutdown() wasn't invoked by our owner after having called Init().
     // This usually means it's an early shutdown and
     // BrowserProcessImpl::StartTearDown() wasn't invoked.
     // Cleanup properly in those cases and avoid crashing the ToastCrasher test.
     Shutdown();
   }
@@ skipping 94 matching lines @@
     device_local_account_policy_service_->Disconnect();
   global_user_cloud_policy_provider_.Shutdown();
 #endif
 
   device_management_service_.reset();
 
   request_context_ = NULL;
 }
 
 PolicyService* BrowserPolicyConnector::GetPolicyService() {
-  if (!policy_service_) {
-    std::vector<ConfigurationPolicyProvider*> providers;
-#if defined(OS_CHROMEOS)
-    providers.push_back(&global_user_cloud_policy_provider_);
-#endif
-    policy_service_ = CreatePolicyService(providers);
-  }
   return policy_service_.get();
 }
 
 #if defined(OS_CHROMEOS)
 bool BrowserPolicyConnector::IsEnterpriseManaged() {
   return install_attributes_ && install_attributes_->IsEnterpriseDevice();
 }
 
 std::string BrowserPolicyConnector::GetEnterpriseDomain() {
   return install_attributes_ ? install_attributes_->GetDomain() : std::string();
@@ skipping 23 matching lines @@
     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));
+
+  // Create the global descriptor.
   scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
       POLICY_DOMAIN_CHROME);
-  service->RegisterPolicyDomain(descriptor);
+  std::string err;
+  scoped_ptr<PolicySchema> schema = PolicySchema::Parse(kPolicyJsonSchema,
+                                                        &err);
+  CHECK(err == "") << err;

[Joao da Silva, 2013/09/11 13:32:02]

CHECK(schema) << err

+  descriptor->RegisterComponent("", schema.Pass());
+  service->InitialRegisterPolicyDomain(descriptor);
   return service.Pass();
 }
 
 const ConfigurationPolicyHandlerList*
     BrowserPolicyConnector::GetHandlerList() const {
   return &handler_list_;
 }
 
 UserAffiliation BrowserPolicyConnector::GetUserAffiliation(
     const std::string& user_name) {
@@ skipping 159 matching lines @@
     return new AsyncPolicyProvider(loader.Pass());
   } else {
     return NULL;
   }
 #else
   return NULL;
 #endif
 }
 
 }  // namespace policy