Enable side-by-side beta and dev channels.

chrome/installer/util/prebuild/create_string_rc.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.
 
 """Generates .h and .rc files for installer strings. Run "python
 create_string_rc.py" for usage details.
 
 This script generates an rc file and header (NAME.{rc,h}) to be included in
 setup.exe. The rc file includes translations for strings pulled from the given
@@ skipping 26 matching lines @@
 import sys
 from xml import sax
 
 BASEDIR = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(os.path.join(BASEDIR, '../../../../tools/grit'))
 sys.path.append(os.path.join(BASEDIR, '../../../../tools/python'))
 
 from grit.extern import tclib
 
 # The IDs of strings we want to import from the .grd files and include in
-# setup.exe's resources.
+# setup.exe's resources. These strings are universal for all brands.
 STRING_IDS = [
   'IDS_ABOUT_VERSION_COMPANY_NAME',
   'IDS_APP_SHORTCUTS_SUBDIR_NAME',
-  'IDS_APP_SHORTCUTS_SUBDIR_NAME_CANARY',
   'IDS_INBOUND_MDNS_RULE_DESCRIPTION',
-  'IDS_INBOUND_MDNS_RULE_DESCRIPTION_CANARY',
   'IDS_INBOUND_MDNS_RULE_NAME',
-  'IDS_INBOUND_MDNS_RULE_NAME_CANARY',
   'IDS_INSTALL_EXISTING_VERSION_LAUNCHED',
   'IDS_INSTALL_FAILED',
   'IDS_INSTALL_HIGHER_VERSION',
   'IDS_INSTALL_INSUFFICIENT_RIGHTS',
   'IDS_INSTALL_INVALID_ARCHIVE',
   'IDS_INSTALL_OS_ERROR',
   'IDS_INSTALL_OS_NOT_SUPPORTED',
   'IDS_INSTALL_SINGLETON_ACQUISITION_FAILED',
   'IDS_INSTALL_TEMP_DIR_FAILED',
   'IDS_INSTALL_UNCOMPRESSION_FAILED',
   'IDS_PRODUCT_DESCRIPTION',
   'IDS_PRODUCT_NAME',
   'IDS_SAME_VERSION_REPAIR_FAILED',
   'IDS_SETUP_PATCH_FAILED',
   'IDS_SHORTCUT_NEW_WINDOW',
   'IDS_SHORTCUT_TOOLTIP',
-  'IDS_SXS_SHORTCUT_NAME',
 ]
 
 # Certain strings are conditional on a brand's install mode (see
 # chrome/install_static/install_modes.h for details). This allows
 # installer::GetLocalizedString to return a resource specific to the current
 # install mode at runtime (e.g., "Google Chrome SxS" as IDS_SHORTCUT_NAME for
 # the localized shortcut name for Google Chrome's canary channel).
 # l10n_util::GetStringUTF16 (used within the rest of Chrome) is unaffected, and
 # will always return the requested string.
 #
@@ skipping 16 matching lines @@
 # 'resource_id_1' names an existing string ID. All calls to
 # installer::GetLocalizedString with this string ID will map to the
 # mode-specific string.
 #
 # Note: Update the test expectations in GetBaseMessageIdForMode.GoogleStringIds
 # when adding to/modifying this structure.
 MODE_SPECIFIC_STRINGS = {
   'IDS_APP_SHORTCUTS_SUBDIR_NAME': {
     'google_chrome': [
       'IDS_APP_SHORTCUTS_SUBDIR_NAME',
+      'IDS_APP_SHORTCUTS_SUBDIR_NAME_BETA',
+      'IDS_APP_SHORTCUTS_SUBDIR_NAME_DEV',
       'IDS_APP_SHORTCUTS_SUBDIR_NAME_CANARY',
     ],
     'chromium': [
       'IDS_APP_SHORTCUTS_SUBDIR_NAME',
     ],
   },
   'IDS_INBOUND_MDNS_RULE_DESCRIPTION': {
     'google_chrome': [
       'IDS_INBOUND_MDNS_RULE_DESCRIPTION',
+      'IDS_INBOUND_MDNS_RULE_DESCRIPTION_BETA',
+      'IDS_INBOUND_MDNS_RULE_DESCRIPTION_DEV',
       'IDS_INBOUND_MDNS_RULE_DESCRIPTION_CANARY',
     ],
     'chromium': [
       'IDS_INBOUND_MDNS_RULE_DESCRIPTION',
     ],
   },
   'IDS_INBOUND_MDNS_RULE_NAME': {
     'google_chrome': [
       'IDS_INBOUND_MDNS_RULE_NAME',
+      'IDS_INBOUND_MDNS_RULE_NAME_BETA',
+      'IDS_INBOUND_MDNS_RULE_NAME_DEV',
       'IDS_INBOUND_MDNS_RULE_NAME_CANARY',
     ],
     'chromium': [
       'IDS_INBOUND_MDNS_RULE_NAME',
     ],
   },
   # In contrast to the strings above, this one (IDS_PRODUCT_NAME) is used
   # throughout Chrome in mode-independent contexts. Within the installer (the
   # place where this mapping matters), it is only used for mode-specific strings
   # such as the name of Chrome's shortcut.
   'IDS_PRODUCT_NAME': {
     'google_chrome': [
       'IDS_PRODUCT_NAME',
+      'IDS_SHORTCUT_NAME_BETA',
+      'IDS_SHORTCUT_NAME_DEV',
       'IDS_SXS_SHORTCUT_NAME',
     ],
     'chromium': [
       'IDS_PRODUCT_NAME',
     ],
   },
 }
 # Note: Update the test expectations in GetBaseMessageIdForMode.GoogleStringIds
 # when adding to/modifying the above structure.
 
 # The ID of the first resource string.
 FIRST_RESOURCE_ID = 1600
 
 
 class GrdHandler(sax.handler.ContentHandler):
   """Extracts selected strings from a .grd file.
 
   Attributes:
     messages: A dict mapping string identifiers to their corresponding messages.
   """
-  def __init__(self, string_ids):
+  def __init__(self, string_id_set):
     """Constructs a handler that reads selected strings from a .grd file.
 
     The dict attribute |messages| is populated with the strings that are read.
 
     Args:
-      string_ids: A list of message identifiers to extract.
+      string_id_set: A set of message identifiers to extract.
     """
     sax.handler.ContentHandler.__init__(self)
     self.messages = {}
-    self.__id_set = set(string_ids)
+    self.__id_set = string_id_set
     self.__message_name = None
     self.__element_stack = []
     self.__text_scraps = []
     self.__characters_callback = None
 
   def startElement(self, name, attrs):
     self.__element_stack.append(name)
     if name == 'message':
       self.__OnOpenMessage(attrs.getValue('name'))
 
@@ skipping 118 matching lines @@
         'installer_util_strings').
       inputs: A list of (grd_file, xtb_dir) pairs containing the source data.
       outdir: The directory into which the files will be generated.
     """
     self.name = name
     self.inputs = inputs
     self.outdir = outdir
     self.brand = brand
 
   def MakeFiles(self):
-    translated_strings = self.__ReadSourceAndTranslatedStrings()
+    string_id_set = self.__BuildStringIds()
+    translated_strings = self.__ReadSourceAndTranslatedStrings(string_id_set)
     self.__WriteRCFile(translated_strings)
-    self.__WriteHeaderFile(translated_strings)
+    self.__WriteHeaderFile(string_id_set, translated_strings)
 
   class __TranslationData(object):
     """A container of information about a single translation."""
     def __init__(self, resource_id_str, language, translation):
       self.resource_id_str = resource_id_str
       self.language = language
       self.translation = translation
 
     def __cmp__(self, other):
       """Allow __TranslationDatas to be sorted by id then by language."""
       id_result = cmp(self.resource_id_str, other.resource_id_str)
       return cmp(self.language, other.language) if id_result == 0 else id_result
 
-  def __ReadSourceAndTranslatedStrings(self):
+  def __BuildStringIds(self):
+    """Returns the set of string IDs to extract from the grd and xtb files."""
+    # Start with the strings that apply to all brands.
+    string_id_set = set(STRING_IDS)
+    # Add in the strings for the current brand.
+    for string_id, brands in MODE_SPECIFIC_STRINGS.iteritems():
+      brand_strings = brands.get(self.brand)
+      if not brand_strings:
+        raise exceptions.RuntimeError(
+          'No strings declared for brand \'%s\' in MODE_SPECIFIC_STRINGS for '
+          'message %s' % (self.brand, string_id))
+      string_id_set.update(brand_strings)
+    return string_id_set
+
+  def __ReadSourceAndTranslatedStrings(self, string_id_set):
     """Reads the source strings and translations from all inputs."""
     translated_strings = []
     for grd_file, xtb_dir in self.inputs:
       # Get the name of the grd file sans extension.
       source_name = os.path.splitext(os.path.basename(grd_file))[0]
       # Compute a glob for the translation files.
       xtb_pattern = os.path.join(os.path.dirname(grd_file), xtb_dir,
                                  '%s*.xtb' % source_name)
       translated_strings.extend(
-        self.__ReadSourceAndTranslationsFrom(grd_file, glob.glob(xtb_pattern)))
+        self.__ReadSourceAndTranslationsFrom(string_id_set, grd_file,
+                                             glob.glob(xtb_pattern)))
     translated_strings.sort()
     return translated_strings
 
-  def __ReadSourceAndTranslationsFrom(self, grd_file, xtb_files):
+  def __ReadSourceAndTranslationsFrom(self, string_id_set, grd_file, xtb_files):
     """Reads source strings and translations for a .grd file.
 
     Reads the source strings and all available translations for the messages
-    identified by STRING_IDS. The source string is used where translations are
-    missing.
+    identified by string_id_set. The source string is used where translations
+    are missing.
 
     Args:
+      string_id_set: The identifiers of the strings to read.
       grd_file: Path to a .grd file.
       xtb_files: List of paths to .xtb files.
 
     Returns:
       An unsorted list of __TranslationData instances.
     """
     sax_parser = sax.make_parser()
 
     # Read the source (en-US) string from the .grd file.
-    grd_handler = GrdHandler(STRING_IDS)
+    grd_handler = GrdHandler(string_id_set)
     sax_parser.setContentHandler(grd_handler)
     sax_parser.parse(grd_file)
     source_strings = grd_handler.messages
 
     # Manually put the source strings as en-US in the list of translated
     # strings.
     translated_strings = []
     for string_id, message_text in source_strings.iteritems():
       translated_strings.append(self.__TranslationData(string_id,
                                                        'EN_US',
@@ skipping 43 matching lines @@
       for translation in translated_strings:
         # Escape special characters for the rc file.
         escaped_text = (translation.translation.replace('"', '""')
                        .replace('\t', '\\t')
                        .replace('\n', '\\n'))
         outfile.write(u'  %s "%s"\n' %
                       (translation.resource_id_str + '_' + translation.language,
                        escaped_text))
       outfile.write(FOOTER_TEXT)
 
-  def __WriteHeaderFile(self, translated_strings):
+  def __WriteHeaderFile(self, string_id_set, translated_strings):
     """Writes a .h file with resource ids."""
     # TODO(grt): Stream the lines to the file rather than building this giant
     # list of lines first.
     lines = []
     do_languages_lines = ['\n#define DO_LANGUAGES']
     installer_string_mapping_lines = ['\n#define DO_INSTALLER_STRING_MAPPING']
     do_mode_strings_lines = ['\n#define DO_MODE_STRINGS']
 
     # Write the values for how the languages ids are offset.
     seen_languages = set()
@@ skipping 23 matching lines @@
       brand_strings = brands.get(self.brand)
       if not brand_strings:
         raise exceptions.RuntimeError(
           'No strings declared for brand \'%s\' in MODE_SPECIFIC_STRINGS for '
           'message %s' % (self.brand, string_id))
       do_mode_strings_lines.append(
         '  HANDLE_MODE_STRING(%s_BASE, %s)'
         % (string_id, ', '.join([ ('%s_BASE' % s) for s in brand_strings])))
 
     # Write out base ID values.
-    for string_id in STRING_IDS:
+    for string_id in sorted(string_id_set):
       lines.append('#define %s_BASE %s_%s' % (string_id,
                                               string_id,
                                               translated_strings[0].language))
       installer_string_mapping_lines.append('  HANDLE_STRING(%s_BASE, %s)'
                                             % (string_id, string_id))
 
     with open(os.path.join(self.outdir, self.name + '.h'), 'wb') as outfile:
       outfile.write('\n'.join(lines))
       outfile.write('\n#ifndef RC_INVOKED')
       outfile.write(' \\\n'.join(do_languages_lines))
@@ skipping 38 matching lines @@
 
 
 def main():
   args = ParseCommandLine()
   StringRcMaker(args.name, args.inputs, args.outdir, args.brand).MakeFiles()
   return 0
 
 
 if '__main__' == __name__:
   sys.exit(main())