Sending known policy names for extensions to chrome://policy page

chrome/browser/ui/webui/policy_ui.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/ui/webui/policy_ui.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud/cloud_policy_client.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/cloud_policy_core.h"
 #include "chrome/browser/policy/cloud/cloud_policy_refresh_scheduler.h"
 #include "chrome/browser/policy/cloud/cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/cloud_policy_validator.h"
 #include "chrome/browser/policy/cloud/message_util.h"
 #include "chrome/browser/policy/configuration_policy_handler_list.h"
+#include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/browser/policy/policy_error_map.h"
 #include "chrome/browser/policy/policy_map.h"
+#include "chrome/browser/policy/policy_schema.h"
 #include "chrome/browser/policy/policy_service.h"
 #include "chrome/browser/policy/policy_types.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/time_format.h"
@@ skipping 452 matching lines @@
       base::Bind(&PolicyUIHandler::HandleInitialized, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "reloadPolicies",
       base::Bind(&PolicyUIHandler::HandleReloadPolicies,
                  base::Unretained(this)));
 }
 
 void PolicyUIHandler::OnPolicyUpdated(const policy::PolicyNamespace& ns,
                                       const policy::PolicyMap& previous,
                                       const policy::PolicyMap& current) {
+  SendPolicyNames();
   SendPolicyValues();
 }
 
 void PolicyUIHandler::SendPolicyNames() const {
   base::DictionaryValue names;
+
+  // Add Chrome policy names.
+  base::DictionaryValue* chrome_policy_names = new base::DictionaryValue;
   const policy::PolicyDefinitionList* list =
       policy::GetChromePolicyDefinitionList();
   for (const policy::PolicyDefinitionList::Entry* entry = list->begin;
        entry != list->end; ++entry) {
-    names.SetBoolean(entry->name, true);
+    chrome_policy_names->SetBoolean(entry->name, true);
   }
+  names.Set("chromePolicyNames", chrome_policy_names);
+
+  // Add extension policy names.
+  base::DictionaryValue* extension_policy_names = new base::DictionaryValue;
+
+  // Get extensions.
+  extensions::ExtensionSystem* extension_system =
+       extensions::ExtensionSystem::Get(Profile::FromWebUI(web_ui()));
+  const ExtensionSet* extensions =
+      extension_system->extension_service()->extensions();
+
+  // Add all extension names to the map.
+  for (ExtensionSet::const_iterator it = extensions->begin();
+       it != extensions->end(); ++it) {
+    const extensions::Extension* extension = *it;
+
+    // Skip this extension if it's a component extension.
+    if (extension->location() == extensions::Manifest::COMPONENT)
+      continue;
+
+    base::DictionaryValue* extension_value = new base::DictionaryValue;
+    extension_value->SetString("name", extension->name());
+    extension_policy_names->Set(extension->id(), extension_value);
+  }
+
+  // Get the policy schema map.
+  scoped_refptr<const policy::PolicyDomainDescriptor> policy_domain_descriptor;
+  policy_domain_descriptor = GetPolicyService()->
+      GetPolicyDomainDescriptor(policy::POLICY_DOMAIN_EXTENSIONS);
+  const policy::PolicyDomainDescriptor::SchemaMap& schema_map =
+      policy_domain_descriptor->components();
+
+  // Add policy names for extensions which are in the policy schema map.
+  policy::PolicyDomainDescriptor::SchemaMap::const_iterator it_map;
+  for (it_map = schema_map.begin(); it_map != schema_map.end(); it_map++) {
+    // Skip this extension if it doesn't have a policy schema,
+    // or if it is a component extension.
+    if (it_map->second == NULL ||
+        extensions->GetByID(it_map->first)->location() ==
+            extensions::Manifest::COMPONENT)
+      continue;
+
+    // Get policy names from the extension's policy schema.
+    // Store in a map, not an array, for faster lookup on JS side.
+    base::DictionaryValue* policy_names = new base::DictionaryValue;
+    const policy::PolicySchemaMap* policies = it_map->second->GetProperties();
+    policy::PolicySchemaMap::const_iterator it_policies;
+    for (it_policies = policies->begin(); it_policies != policies->end();
+         it_policies++) {
+      policy_names->SetBoolean(it_policies->first, true);
+    }
+
+    // Add policy names to extension's entry in the dictionary.
+    base::DictionaryValue* extension_value = new base::DictionaryValue;
+    extension_policy_names->GetDictionary(it_map->first, &extension_value);
+    extension_value->Set("policyNames", policy_names);
+  }

[Joao da Silva, 2013/06/18 13:26:04]

Have a single for loop:

- get the list of all extensions as in lines 526-529;
- then get the schema_map as in lines 546-550;
- then iterate over all the extensions, skipping non enterprise extensions, as
in lines 532-543;
- after setting the extension name, get its PolicySchemaMap and add the policy
names for that extension:

  policy::PolicyDomainDescriptor::SchemaMap::const_iterator it =
      schema_map.find(extension->id());
  if (it == schema_map.end()) {
    NOTREACHED();
    continue;
  }

  const policy::PolicySchemaMap* policies = it->second->GetProperties();
  // loop from lines 567-570

[anitawoodruff, 2013/06/18 14:53:38]

I've combined it into a single for-loop, but that NOTREACHED() check fails,
possibly because in this branch I don't filter out non-enterprise extensions
(that's in the other review). (Wouldn't enterprise extensions without any
policies also cause it to fail??) Anyway, instead of NOTREACHED() here I'm
saving the entry to the map  before continuing, so the name and 'No policies
set' element can be shown for extensions without policies.

+
+  names.Set("extensionPolicyNames", extension_policy_names);
   web_ui()->CallJavascriptFunction("policy.Page.setPolicyNames", names);
 }
 
 void PolicyUIHandler::SendPolicyValues() const {
   base::DictionaryValue all_policies;
 
   // Add chrome policies.
   base::DictionaryValue* chrome_policies = new base::DictionaryValue;
   GetChromePolicyValues(chrome_policies);
   all_policies.Set("chromePolicies", chrome_policies);
 
   // Get extensions.
   extensions::ExtensionSystem* extension_system =
        extensions::ExtensionSystem::Get(Profile::FromWebUI(web_ui()));
   const ExtensionSet* extensions =
       extension_system->extension_service()->extensions();
 
   // Add policies for each extension.
   base::DictionaryValue* extension_values = new base::DictionaryValue;
   for (ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     const extensions::Extension* extension = *it;
 
     // Skip this extension if it's a component extension.
     if (extension->location() == extensions::Manifest::COMPONENT)
       continue;
 
-    base::DictionaryValue* extension_value = new base::DictionaryValue;
-
-    // Add name.
-    extension_value->SetString("name", extension->name());
-
-    // Add policies.
+    // Add policies values.
+    // Store in a map, not an array, for faster lookup on JS side.
     base::DictionaryValue* extension_policies = new base::DictionaryValue;
     policy::PolicyNamespace policy_namespace = policy::PolicyNamespace(
         policy::POLICY_DOMAIN_EXTENSIONS, extension->id());
     policy::PolicyErrorMap empty_error_map;
     GetPolicyValues(GetPolicyService()->GetPolicies(policy_namespace),
                     &empty_error_map, extension_policies);
-    extension_value->Set("policies", extension_policies);
 
     // Add entry to the dictionary.
-    extension_values->Set(extension->id(), extension_value);
+    extension_values->Set(extension->id(), extension_policies);
   }
   all_policies.Set("extensionPolicies", extension_values);
 
   web_ui()->CallJavascriptFunction("policy.Page.setPolicyValues", all_policies);
 }
 
 void PolicyUIHandler::GetPolicyValues(const policy::PolicyMap& map,
                                       policy::PolicyErrorMap* errors,
                                       base::DictionaryValue* values) const {
   for (policy::PolicyMap::const_iterator entry = map.begin();
@@ skipping 80 matching lines @@
 }
 
 PolicyUI::PolicyUI(content::WebUI* web_ui) : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new PolicyUIHandler);
   content::WebUIDataSource::Add(Profile::FromWebUI(web_ui),
                                 CreatePolicyUIHTMLSource());
 }
 
 PolicyUI::~PolicyUI() {
 }