Removed the PolicyDefinitionList.

chrome/browser/policy/policy_loader_win.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/policy_loader_win.h"
 
 #include <rpc.h>      // For struct GUID
 #include <shlwapi.h>  // For PathIsUNC()
 #include <userenv.h>  // For GPO functions
 #include <windows.h>
@@ skipping 15 matching lines @@
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_load_status.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/preg_parser_win.h"
 #include "chrome/browser/policy/registry_dict_win.h"
 #include "components/json_schema/json_schema_constants.h"
+#include "components/policy/core/common/policy_namespace.h"
+#include "components/policy/core/common/schema.h"
 #include "policy/policy_constants.h"
 
 namespace schema = json_schema_constants;
 
 namespace policy {
 
 namespace {
 
 const char kKeyMandatory[] = "policy";
 const char kKeyRecommended[] = "recommended";
@@ skipping 157 matching lines @@
   policy->LoadFrom(policy_dict, level, scope);
 }
 
 }  // namespace
 
 const base::FilePath::CharType PolicyLoaderWin::kPRegFileName[] =
     FILE_PATH_LITERAL("Registry.pol");
 
 PolicyLoaderWin::PolicyLoaderWin(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
-    const PolicyDefinitionList* policy_list,
     const string16& chrome_policy_key,
     AppliedGPOListProvider* gpo_provider)
     : AsyncPolicyLoader(task_runner),
       is_initialized_(false),
-      policy_list_(policy_list),
       chrome_policy_key_(chrome_policy_key),
       gpo_provider_(gpo_provider),
       user_policy_changed_event_(false, false),
       machine_policy_changed_event_(false, false),
       user_policy_watcher_failed_(false),
       machine_policy_watcher_failed_(false) {
   if (!::RegisterGPNotification(user_policy_changed_event_.handle(), false)) {
     DPLOG(WARNING) << "Failed to register user group policy notification";
     user_policy_watcher_failed_ = true;
   }
   if (!::RegisterGPNotification(machine_policy_changed_event_.handle(), true)) {
     DPLOG(WARNING) << "Failed to register machine group policy notification.";
     machine_policy_watcher_failed_ = true;
   }
 }
 
 PolicyLoaderWin::~PolicyLoaderWin() {
   if (!user_policy_watcher_failed_) {
     ::UnregisterGPNotification(user_policy_changed_event_.handle());
     user_policy_watcher_.StopWatching();
   }
   if (!machine_policy_watcher_failed_) {
     ::UnregisterGPNotification(machine_policy_changed_event_.handle());
     machine_policy_watcher_.StopWatching();
   }
 }
 
 // static
 scoped_ptr<PolicyLoaderWin> PolicyLoaderWin::Create(
-    scoped_refptr<base::SequencedTaskRunner> task_runner,
-    const PolicyDefinitionList* policy_list) {
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
   return make_scoped_ptr(
-      new PolicyLoaderWin(task_runner, policy_list, kRegistryChromePolicyKey,
+      new PolicyLoaderWin(task_runner,
+                          kRegistryChromePolicyKey,
                           g_win_gpo_list_provider.Pointer()));
 }
 
 void PolicyLoaderWin::InitOnBackgroundThread() {
   is_initialized_ = true;
   SetupWatches();
 }
 
 scoped_ptr<PolicyBundle> PolicyLoaderWin::Load() {
   // Reset the watches BEFORE reading the individual policies to avoid
@@ skipping 58 matching lines @@
 
     // Load 3rd-party policy.
     if (third_party_dict)
       Load3rdPartyPolicy(third_party_dict.get(), scope, bundle.get());
   }
 
   return bundle.Pass();
 }
 
 void PolicyLoaderWin::BuildChromePolicySchema() {
+  // TODO(joaodasilva): use the Schema directly instead of building this
+  // DictionaryValue.
   scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue());
-  for (const PolicyDefinitionList::Entry* e = policy_list_->begin;
-       e != policy_list_->end; ++e) {
-    const std::string schema_type = GetSchemaTypeForValueType(e->value_type);
+  const Schema* chrome_schema =
+      schema_map()->GetSchema(PolicyNamespace(POLICY_DOMAIN_CHROME, ""));
+  for (Schema::Iterator it = chrome_schema->GetPropertiesIterator();
+       !it.IsAtEnd(); it.Advance()) {
+    const std::string schema_type =
+        GetSchemaTypeForValueType(it.schema().type());
     scoped_ptr<base::DictionaryValue> entry_schema(new base::DictionaryValue());
     entry_schema->SetStringWithoutPathExpansion(json_schema_constants::kType,
                                                 schema_type);
 
-    if (e->value_type == base::Value::TYPE_LIST) {
+    if (it.schema().type() == base::Value::TYPE_LIST) {
       scoped_ptr<base::DictionaryValue> items_schema(
           new base::DictionaryValue());
       items_schema->SetStringWithoutPathExpansion(
           json_schema_constants::kType, json_schema_constants::kString);
       entry_schema->SetWithoutPathExpansion(json_schema_constants::kItems,
                                             items_schema.release());
     }
-    properties->SetWithoutPathExpansion(e->name, entry_schema.release());
+    properties->SetWithoutPathExpansion(it.key(), entry_schema.release());
   }
   chrome_policy_schema_.SetStringWithoutPathExpansion(
       json_schema_constants::kType, json_schema_constants::kObject);
   chrome_policy_schema_.SetWithoutPathExpansion(
       json_schema_constants::kProperties, properties.release());
 }
 
 bool PolicyLoaderWin::ReadPRegFile(const base::FilePath& preg_file,
                                    RegistryDict* policy,
                                    PolicyLoadStatusSample* status) {
@@ skipping 178 matching lines @@
 
 void PolicyLoaderWin::OnObjectSignaled(HANDLE object) {
   DCHECK(object == user_policy_changed_event_.handle() ||
          object == machine_policy_changed_event_.handle())
       << "unexpected object signaled policy reload, obj = "
       << std::showbase << std::hex << object;
   Reload(false);
 }
 
 }  // namespace policy