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();

[anitawoodruff, 2013/06/18 09:14:10]

This seemed necessary now that extension names get sent through with policy
names, because otherwise if a new extension got added and a policy set on it,
the policy table didn't get added to the page. However, this does mean we are
sending through all the policy names whenever anything changes, which may be
overkill. Thoughts? 

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

Yes, this is overkill. The right way to do it is to make this class a
content::NotificationObserver and register to receive
NOTIFICATION_EXTENSION_LOADED, and SendPolicyNames() when that notification is
received.

This class can also observe NOTIFICATION_EXTENSION_UNLOADED to remove a table
when an extension is removed. So the javascript side has to drop all tables and
create them again whenever SendPolicyNames() is received. SendPolicyValues()
should also be sent immediately after to send values for the new tables.

[anitawoodruff, 2013/06/19 13:36:44]

Done.

   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);
+  }
+
+  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() {
 }