DevTools: remove release mode from runtime.

third_party/WebKit/Source/devtools/scripts/concatenate_application_code.py

 #!/usr/bin/env python
 #
 # Copyright 2014 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.
 
 """
 Release:
   - Concatenates autostart modules, application modules' module.json descriptors,
     and the application loader into a single script.
@@ skipping 24 matching lines @@
 
 def resource_source_url(url):
     return '\n/*# sourceURL=' + url + ' */'
 
 
 def minify_js(javascript):
     return rjsmin.jsmin(javascript)
 
 
 def concatenated_module_filename(module_name, output_dir):
-    return join(output_dir, module_name + '_module.js')
+    return join(output_dir, module_name + '/' + module_name + '_module.js')
 
 
 def symlink_or_copy_file(src, dest, safe=False):
     if safe and path.exists(dest):
         os.remove(dest)
     if hasattr(os, 'symlink'):
         os.symlink(src, dest)
     else:
         shutil.copy(src, dest)
 
@@ skipping 75 matching lines @@
         if (resource_path.endswith('.js')):
             return '    <script type="text/javascript" src="%s"></script>\n' % resource_path
         else:
             assert resource_path
 
     def _release_module_descriptors(self):
         module_descriptors = self.descriptors.modules
         result = []
         for name in module_descriptors:
             module = copy.copy(module_descriptors[name])
+            module_type = self.descriptors.application[name].get('type')
             # Clear scripts, as they are not used at runtime
             # (only the fact of their presence is important).
             resources = module.get('resources', None)
             if module.get('scripts') or resources:
-                module['scripts'] = []
-            # Resources list is not used at runtime.
+                if module_type == 'autostart':
+                    # Autostart modules are already baked in.
+                    del module['scripts']
+                else:
+                    # Non-autostart modules are vulcanized.
+                    module['scripts'] = [name + '_module.js']
+            # Resources are already baked into scripts.
             if resources is not None:
                 del module['resources']
-            condition = self.descriptors.application[name].get('condition')
-            if condition:
-                module['condition'] = condition
-            type = self.descriptors.application[name].get('type')
-            if type == 'remote':
+            if module_type == 'remote':
                 module['remote'] = True
             result.append(module)
         return json.dumps(result)
 
     def _write_module_resources(self, resource_names, output):
         for resource_name in resource_names:
             resource_name = path.normpath(resource_name).replace('\\', '/')
             output.write('Runtime.cachedResources["%s"] = "' % resource_name)
             resource_content = read_file(path.join(self.application_dir, resource_name)) + resource_source_url(resource_name)
             resource_content = resource_content.replace('\\', '\\\\')
@@ skipping 74 matching lines @@
         symlink_or_copy_file(join(os.getcwd(), self.application_dir, html_name), join(self.output_dir, html_name), True)
 
 
 def build_application(application_name, loader, application_dir, output_dir, release_mode):
     descriptors = loader.load_application(application_name + '.json')
     if release_mode:
         builder = ReleaseBuilder(application_name, descriptors, application_dir, output_dir)
     else:
         builder = DebugBuilder(application_name, descriptors, application_dir, output_dir)
     builder.build_app()