DO NOT SUBMIT shrink R.java files via inheritance

build/android/gyp/process_resources.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.
 
 """Process Android resources to generate R.java, and prepare for packaging.
 
 This will crunch images and generate v14 compatible resources
 (see generate_v14_compatible_resources.py).
 """
 
 import codecs
 import collections
 import optparse
 import os
 import re
 import shutil
 import sys
 import xml.etree.ElementTree
 
 import generate_v14_compatible_resources
 
 from util import build_utils
 
+_ROOT_R_JAVA_PACKAGE_PREFIX = 'gen'
+
+
 # Import jinja2 from third_party/jinja2
 sys.path.insert(1,
     os.path.join(os.path.dirname(__file__), '../../../third_party'))
 from jinja2 import Template # pylint: disable=F0401
 
 
 # Represents a line from a R.txt file.
 TextSymbolsEntry = collections.namedtuple('RTextEntry',
     ('java_type', 'resource_type', 'name', 'value'))
 
@@ skipping 106 matching lines @@
   if options.extra_r_text_files:
     options.extra_r_text_files = (
         build_utils.ParseGnList(options.extra_r_text_files))
   else:
     options.extra_r_text_files = []
 
   return options
 
 
 def CreateRJavaFiles(srcjar_dir, main_r_txt_file, packages, r_txt_files,
-                     shared_resources):
+                     shared_resources, srcjar_name):
   assert len(packages) == len(r_txt_files), 'Need one R.txt file per package'
 
   # Map of (resource_type, name) -> Entry.
   # Contains the correct values for resources.
   all_resources = {}
+  all_resources_by_type = collections.defaultdict(list)
   for entry in _ParseTextSymbolsFile(main_r_txt_file):
     all_resources[(entry.resource_type, entry.name)] = entry
+    all_resources_by_type[entry.resource_type].append(entry)
+
+  # Write Root R.java.
+  root_r_java_package = _ROOT_R_JAVA_PACKAGE_PREFIX + '.' + srcjar_name
+  root_r_java_dir = os.path.join(srcjar_dir, *root_r_java_package.split('.'))
+  build_utils.MakeDirectory(root_r_java_dir)
+  root_r_java_path = os.path.join(root_r_java_dir, 'R.java')
+  root_java_file_contents = _CreateRootRJavaFile(
+      root_r_java_package, all_resources_by_type, shared_resources)
+  with open(root_r_java_path, 'w') as f:
+    f.write(root_java_file_contents)
 
   # Map of package_name->resource_type->entry
   resources_by_package = (
       collections.defaultdict(lambda: collections.defaultdict(list)))
   # Build the R.java files using each package's R.txt file, but replacing
   # each entry's placeholder value with correct values from all_resources.
   for package, r_txt_file in zip(packages, r_txt_files):
     if package in resources_by_package:
       raise Exception(('Package name "%s" appeared twice. All '
                        'android_resources() targets must use unique package '
@@ skipping 20 matching lines @@
       # correctly by running Proguard on the APK: it will report missing
       # fields.
       if entry:
         resources_by_type[entry.resource_type].append(entry)
 
   for package, resources_by_type in resources_by_package.iteritems():
     package_r_java_dir = os.path.join(srcjar_dir, *package.split('.'))
     build_utils.MakeDirectory(package_r_java_dir)
     package_r_java_path = os.path.join(package_r_java_dir, 'R.java')
     java_file_contents = _CreateRJavaFile(
-        package, resources_by_type, shared_resources)
+        package, root_r_java_package, resources_by_type, shared_resources)
     with open(package_r_java_path, 'w') as f:
       f.write(java_file_contents)
 
 
 def _ParseTextSymbolsFile(path):
   """Given an R.txt file, returns a list of TextSymbolsEntry."""
   ret = []
   with open(path) as f:
     for line in f:
       m = re.match(r'(int(?:\[\])?) (\w+) (\w+) (.+)$', line)
       if not m:
         raise Exception('Unexpected line in R.txt: %s' % line)
       java_type, resource_type, name, value = m.groups()
       ret.append(TextSymbolsEntry(java_type, resource_type, name, value))
   return ret
 
 
-def _CreateRJavaFile(package, resources_by_type, shared_resources):
+def _CreateRJavaFile(
+    package, root_r_java_package, resources_by_type, shared_resources):
+  # TODO fix comments
+  """Generates the contents of a R.java file."""
+  template = Template("""/* AUTO-GENERATED FILE.  DO NOT MODIFY. */
+
+package {{ package }};
+
+public final class R {
+    {% for resource_type in resource_types %}
+    public static final class {{ resource_type }} extends 
+            {{ root_package }}.R.{{ resource_type }} {}
+    {% endfor %}
+    {% if shared_resources %}
+    public static void onResourcesLoaded(int packageId) {
+        {{ root_package }}.R.onResourcesLoaded(packageId);
+    }
+    {% endif %}
+}
+""", trim_blocks=True, lstrip_blocks=True)
+
+  return template.render(package=package,
+                         resources=resources_by_type,
+                         resource_types=sorted(resources_by_type),
+                         root_package=root_r_java_package,
+                         shared_resources=shared_resources)
+
+
+def _CreateRootRJavaFile(package, all_resources_by_type, shared_resources):
+  # TODO fix comments
   """Generates the contents of a R.java file."""
   # Keep these assignments all on one line to make diffing against regular
   # aapt-generated files easier.
   create_id = ('{{ e.resource_type }}.{{ e.name }} ^= packageIdTransform;')
   create_id_arr = ('{{ e.resource_type }}.{{ e.name }}[i] ^='
                    ' packageIdTransform;')
   # Here we diverge from what aapt does. Because we have so many
   # resources, the onResourcesLoaded method was exceeding the 64KB limit that
   # Java imposes. For this reason we split onResourcesLoaded into different
   # methods for each resource type.
   template = Template("""/* AUTO-GENERATED FILE.  DO NOT MODIFY. */
 
 package {{ package }};
 
 public final class R {
     private static boolean sResourcesDidLoad;
     {% for resource_type in resource_types %}
-    public static final class {{ resource_type }} {
+    public static class {{ resource_type }} {
         {% for e in resources[resource_type] %}
         {% if shared_resources %}
         public static {{ e.java_type }} {{ e.name }} = {{ e.value }};
         {% else %}
         public static final {{ e.java_type }} {{ e.name }} = {{ e.value }};
         {% endif %}
         {% endfor %}
     }
     {% endfor %}
     {% if shared_resources %}
     public static void onResourcesLoaded(int packageId) {
-        assert !sResourcesDidLoad;
+        if (sResourcesDidLoad) {
+            return;
+        }
         sResourcesDidLoad = true;
         int packageIdTransform = (packageId ^ 0x7f) << 24;
         {% for resource_type in resource_types %}
         onResourcesLoaded{{ resource_type|title }}(packageIdTransform);
         {% for e in resources[resource_type] %}
         {% if e.java_type == 'int[]' %}
         for(int i = 0; i < {{ e.resource_type }}.{{ e.name }}.length; ++i) {
             """ + create_id_arr + """
         }
         {% endif %}
         {% endfor %}
         {% endfor %}
     }
     {% for res_type in resource_types %}
     private static void onResourcesLoaded{{ res_type|title }} (
             int packageIdTransform) {
         {% for e in resources[res_type] %}
         {% if res_type != 'styleable' and e.java_type != 'int[]' %}
         """ + create_id + """
         {% endif %}
         {% endfor %}
     }
     {% endfor %}
     {% endif %}
 }
 """, trim_blocks=True, lstrip_blocks=True)
 
   return template.render(package=package,
-                         resources=resources_by_type,
-                         resource_types=sorted(resources_by_type),
+                         resources=all_resources_by_type,
+                         resource_types=sorted(all_resources_by_type),
                          shared_resources=shared_resources)
 
 
 def CrunchDirectory(aapt, input_dir, output_dir):
   """Crunches the images in input_dir and its subdirectories into output_dir.
 
   If an image is already optimized, crunching often increases image size. In
   this case, the crunched image is overwritten with the original image.
   """
   aapt_cmd = [aapt,
@@ skipping 183 matching lines @@
       # - there was already a dependent android_resources() with the same
       #   package (occurs mostly when an apk target and resources target share
       #   an AndroidManifest.xml)
       if cur_package != 'dummy.package' and cur_package not in packages:
         packages.append(cur_package)
         r_txt_files.append(r_txt_path)
 
       if packages:
         shared_resources = options.shared_resources or options.app_as_shared_lib
         CreateRJavaFiles(srcjar_dir, r_txt_path, packages, r_txt_files,
-                         shared_resources)
+                         shared_resources, os.path.basename(options.srcjar_out))
 
     # This is the list of directories with resources to put in the final .zip
     # file. The order of these is important so that crunched/v14 resources
     # override the normal ones.
     zip_resource_dirs = input_resource_dirs + [v14_dir]
 
     base_crunch_dir = os.path.join(temp_dir, 'crunch')
 
     # Crunch image resources. This shrinks png files and is necessary for
     # 9-patch images to display correctly. 'aapt crunch' accepts only a single
@@ skipping 67 matching lines @@
       options,
       input_paths=input_paths,
       input_strings=input_strings,
       output_paths=output_paths,
       # TODO(agrieve): Remove R_dir when it's no longer used (used only by GYP).
       force=options.R_dir)
 
 
 if __name__ == '__main__':
   main(sys.argv[1:])