Generate ADMX template for Chrome OS policies

components/policy/tools/template_writers/writers/admx_writer.py

 #!/usr/bin/env python
 # 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.
 
 from xml.dom import minidom
 from writers import xml_formatted_writer
 
 
 def GetWriter(config):
   '''Factory method for instanciating the ADMXWriter. Every Writer needs a
   GetWriter method because the TemplateFormatter uses this method to
   instantiate a Writer.
   '''
   return ADMXWriter(['win'], config)
 
 
 class ADMXWriter(xml_formatted_writer.XMLFormattedWriter):
   '''Class for generating an ADMX policy template. It is used by the
   PolicyTemplateGenerator to write the admx file.
   '''
 
   # DOM root node of the generated ADMX document.
   _doc = None
 
   # The ADMX "policies" element that contains the ADMX "policy" elements that
   # are generated.
   _active_policies_elem = None
 
+  def Init(self):
+    # Shortcut to platform-specific ADMX/ADM specific configuration.
+    assert len(self.platforms) == 1
+    self.winconfig = self.config['win_config'][self.platforms[0]]
+
   def _AdmlString(self, name):
     '''Creates a reference to the named string in an ADML file.
     Args:
       name: Name of the referenced ADML string.
     '''
     name = name.replace('.', '_')
     return '$(string.' + name + ')'
 
   def _AdmlStringExplain(self, name):
     '''Creates a reference to the named explanation string in an ADML file.
@@ skipping 74 matching lines @@
     }
     category_elem = self.AddElement(parent, 'category', attributes)
     if parent_category_name:
       attributes = {'ref': parent_category_name}
       self.AddElement(category_elem, 'parentCategory', attributes)
 
   def _AddCategories(self, categories):
     '''Generates the ADMX "categories" element and adds it to the categories
     main node. The "categories" element defines the category for the policies
     defined in this ADMX document. Here is an example of an ADMX "categories"
-    element:
+    element on Windows:
 
     <categories>
       <category displayName="$(string.googlechrome)" name="googlechrome">
         <parentCategory ref="Google:Cat_Google"/>
       </category>
     </categories>
 
     Args:
       categories_path: The categories path e.g. ['google', 'googlechrome']. For
         each level in the path a "category" element will be generated, unless
@@ skipping 63 matching lines @@
     passed parent element.
     '''
     name = policy['name']
     items = policy['items']
     attributes = {
       'id': name,
       'valueName': name,
     }
     enum_elem = self.AddElement(parent, 'enum', attributes)
     for item in items:
-      attributes = {'displayName': self._AdmlString(item['name'])}
+      attributes = {'displayName': self._AdmlString(name + "_" + item['name'])}
       item_elem = self.AddElement(enum_elem, 'item', attributes)
       value_elem = self.AddElement(item_elem, 'value')
       value_string = str(item['value'])
       if policy['type'] == 'int-enum':
         self.AddElement(value_elem, 'decimal', {'value': value_string})
       else:
         self.AddElement(value_elem, 'string', {}, value_string)
 
   def _AddListPolicy(self, parent, key, name):
     '''Generates ADMX XML elements for a List-Policy and adds them to the
@@ skipping 46 matching lines @@
     '''
     policies_elem = self._active_policies_elem
     policy_type = policy['type']
     policy_name = policy['name']
     if policy_type == 'external':
       # This type can only be set through cloud policy.
       return
 
     attributes = {
       'name': name,
-      'class': self.config['win_group_policy_class'],
+      'class': self.GetClass(policy),
       'displayName': self._AdmlString(policy_name),
       'explainText': self._AdmlStringExplain(policy_name),
       'presentation': self._AdmlPresentation(policy_name),
       'key': key,
     }
     # Store the current "policy" AMDX element in self for later use by the
     # WritePolicy method.
     policy_elem = self.AddElement(policies_elem, 'policy',
                                   attributes)
     self.AddElement(policy_elem, 'parentCategory',
@@ skipping 18 matching lines @@
       self._AddListPolicy(parent, key, policy_name)
     elif policy_type == 'group':
       pass
     else:
       raise Exception('Unknown policy type %s.' % policy_type)
 
   def WritePolicy(self, policy):
     if self.CanBeMandatory(policy):
       self._WritePolicy(policy,
                         policy['name'],
-                        self.config['win_reg_mandatory_key_name'],
+                        self.winconfig['reg_mandatory_key_name'],
                         self._active_mandatory_policy_group_name)
 
   def WriteRecommendedPolicy(self, policy):
     self._WritePolicy(policy,
                       policy['name'] + '_recommended',
-                      self.config['win_reg_recommended_key_name'],
+                      self.winconfig['reg_recommended_key_name'],
                       self._active_recommended_policy_group_name)
 
   def _BeginPolicyGroup(self, group, name, parent):
     '''Generates ADMX elements for a Policy-Group.
     '''
     attributes = {
       'name': name,
       'displayName': self._AdmlString(group['name'] + '_group'),
     }
     category_elem = self.AddElement(self._categories_elem,
                                     'category',
                                     attributes)
     attributes = {
       'ref': parent
     }
     self.AddElement(category_elem, 'parentCategory', attributes)
 
   def BeginPolicyGroup(self, group):
     self._BeginPolicyGroup(group,
                            group['name'],
-                           self.config['win_mandatory_category_path'][-1])
+                           self.winconfig['mandatory_category_path'][-1])
     self._active_mandatory_policy_group_name = group['name']
 
   def EndPolicyGroup(self):
     self._active_mandatory_policy_group_name = \
-        self.config['win_mandatory_category_path'][-1]
+        self.winconfig['mandatory_category_path'][-1]
 
   def BeginRecommendedPolicyGroup(self, group):
     self._BeginPolicyGroup(group,
                            group['name'] + '_recommended',
-                           self.config['win_recommended_category_path'][-1])
+                           self.winconfig['recommended_category_path'][-1])
     self._active_recommended_policy_group_name = group['name'] + '_recommended'
 
   def EndRecommendedPolicyGroup(self):
     self._active_recommended_policy_group_name = \
-        self.config['win_recommended_category_path'][-1]
+        self.winconfig['recommended_category_path'][-1]
 
   def BeginTemplate(self):
     '''Generates the skeleton of the ADMX template. An ADMX template contains
     an ADMX "PolicyDefinitions" element with four child nodes: "policies"
     "policyNamspaces", "resources", "supportedOn" and "categories"
     '''
     dom_impl = minidom.getDOMImplementation('')
     self._doc = dom_impl.createDocument(None, 'policyDefinitions', None)
     if self._GetChromiumVersionString() is not None:
       self.AddComment(self._doc.documentElement, self.config['build'] + \
           ' version: ' + self._GetChromiumVersionString())
     policy_definitions_elem = self._doc.documentElement
 
     policy_definitions_elem.attributes['revision'] = '1.0'
     policy_definitions_elem.attributes['schemaVersion'] = '1.0'
 
     self._AddPolicyNamespaces(policy_definitions_elem,
                               self.config['admx_prefix'],
-                              self.config['admx_namespace'])
+                              self.winconfig['namespace'])
     self.AddElement(policy_definitions_elem, 'resources',
                     {'minRequiredRevision' : '1.0'})
     self._AddSupportedOn(policy_definitions_elem,
                          self.config['win_supported_os'])
     self._categories_elem = self.AddElement(policy_definitions_elem,
                                             'categories')
-    self._AddCategories(self.config['win_mandatory_category_path'])
-    self._AddCategories(self.config['win_recommended_category_path'])
+    self._AddCategories(self.winconfig['mandatory_category_path'])
+    self._AddCategories(self.winconfig['recommended_category_path'])
     self._active_policies_elem = self.AddElement(policy_definitions_elem,
                                                  'policies')
     self._active_mandatory_policy_group_name = \
-        self.config['win_mandatory_category_path'][-1]
+        self.winconfig['mandatory_category_path'][-1]
     self._active_recommended_policy_group_name = \
-        self.config['win_recommended_category_path'][-1]
+        self.winconfig['recommended_category_path'][-1]
 
   def GetTemplateText(self):
     return self.ToPrettyXml(self._doc)
+
+  def GetClass(self, policy):
+    return 'Both'