DevTools: Introduce module initializers

Source/devtools/scripts/compile_frontend.py

 #!/usr/bin/env python
 # Copyright (c) 2012 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
 
 import os
 import os.path as path
 import generate_protocol_externs
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 try:
+    import simplejson as json
+except ImportError:
     import json
-except ImportError:
-    import simplejson as json
 
 scripts_path = path.dirname(path.abspath(__file__))
 devtools_path = path.dirname(scripts_path)
 inspector_path = path.join(path.dirname(devtools_path), "core", "inspector")
 devtools_frontend_path = path.join(devtools_path, "front_end")
 global_externs_file = path.join(devtools_frontend_path, "externs.js")
 protocol_externs_file = path.join(devtools_frontend_path, "protocol_externs.js")
 webgl_rendering_context_idl_path = path.join(path.dirname(devtools_path), "core", "html", "canvas", "WebGLRenderingContextBase.idl")
 injected_script_source_name = path.join(inspector_path, "InjectedScriptSource.js")
 canvas_injected_script_source_name = path.join(inspector_path, "InjectedScriptCanvasModuleSource.js")
 closure_compiler_jar = path.join(scripts_path, "closure", "compiler.jar")
 closure_runner_jar = path.join(scripts_path, "compiler-runner", "closure-runner.jar")
 jsdoc_validator_jar = path.join(scripts_path, "jsdoc-validator", "jsdoc-validator.jar")
 java_exec = "java -Xms1024m -server -XX:+TieredCompilation"
 
 generate_protocol_externs.generate_protocol_externs(protocol_externs_file, path.join(devtools_path, "protocol.json"))
 
 jsmodule_name_prefix = "jsmodule_"
-js_modules_name = "frontend_modules.json"
+frontend_modules_name = "frontend_modules.json"
 runtime_module_name = "_runtime"
+module_initializer_name = "_module.js"
 
 
 def error_excepthook(exctype, value, traceback):
     print "ERROR:"
     sys.__excepthook__(exctype, value, traceback)
 sys.excepthook = error_excepthook
 
 try:
-    with open(path.join(scripts_path, js_modules_name), "rt") as js_modules_file:
+    with open(path.join(scripts_path, frontend_modules_name), "rt") as js_modules_file:
         modules = json.loads(js_modules_file.read())
 except:
-    print "ERROR: Failed to read %s" % js_modules_name
+    log_error("Failed to read %s" % frontend_modules_name)
     raise
 
-# `importScript` function must not be used in any files
-# except module headers. Refer to devtools.gyp file for
-# the module header list.
-allowed_import_statements_files = [
-    "console/ConsolePanel.js",
-    "elements/ElementsPanel.js",
-    "resources/ResourcesPanel.js",
-    "network/NetworkPanel.js",
-    "settings/SettingsScreen.js",
-    "sources/SourcesPanel.js",
-    "timeline/TimelinePanel.js",
-    "profiler/ProfilesPanel.js",
-    "audits/AuditsPanel.js",
-    "layers/LayersPanel.js",
-    "extensions/ExtensionServer.js",
-    "source_frame/SourceFrame.js",
-    "documentation/DocumentationView.js",
-]
-
 type_checked_jsdoc_tags_list = ["param", "return", "type", "enum"]
 
 type_checked_jsdoc_tags_or = "|".join(type_checked_jsdoc_tags_list)
 
 # Basic regex for invalid JsDoc types: an object type name ([A-Z][A-Za-z0-9.]+[A-Za-z0-9]) not preceded by '!', '?', ':' (this, new), or '.' (object property).
 invalid_type_regex = re.compile(r"@(?:" + type_checked_jsdoc_tags_or + r")\s*\{.*(?<![!?:.A-Za-z0-9])([A-Z][A-Za-z0-9.]+[A-Za-z0-9])[^/]*\}")
 
 invalid_type_designator_regex = re.compile(r"@(?:" + type_checked_jsdoc_tags_or + r")\s*.*(?<![{: ])([?!])=?\}")
 
 importscript_regex = re.compile(r"importScript\(\s*[\"']")
 error_warning_regex = re.compile(r"(?:WARNING|ERROR)")
 
 errors_found = False
 
 
 def run_in_shell(command_line):
     return subprocess.Popen(command_line, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
 
 
 def hasErrors(output):
     return re.search(error_warning_regex, output) != None
 
 
+def log_error(message):
+    print "ERROR: " + message
+
 def verify_importScript_usage():
     errors_found = False
     for module in modules:
-        for file_name in module['sources']:
-            if file_name in allowed_import_statements_files:
+        for file_name in module["sources"]:
+            if path.basename(file_name) == module_initializer_name:
+                log_error("Module initializer (%s) may not be listed among module's scripts; found in '%s'" % (module_initializer_name, module["name"]))
+                errors_found = True
                 continue
             try:
                 with open(path.join(devtools_frontend_path, file_name), "r") as sourceFile:
                     source = sourceFile.read()
                     if re.search(importscript_regex, source):
-                        print "ERROR: importScript function call is allowed in module header files only (found in %s)" % file_name
+                        log_error("importScript() call only allowed in module initializers (%s); found in %s" % (module_initializer_name, file_name))
                         errors_found = True
             except:
-                print "ERROR: Failed to access %s" % file_name
+                log_error("Failed to access %s" % file_name)
                 raise
     return errors_found
 
 
 def dump_all_checked_files():
     files = {}
     for module in modules:
         for source in module["sources"]:
             files[path.join(devtools_frontend_path, source)] = True
     return files.keys()
@@ skipping 77 matching lines @@
         if not list:
             list = []
             dependents_by_module_name[dep] = list
         list.append(name)
 
 
 def verify_standalone_modules():
     for module in modules:
         for dependency in module["dependencies"]:
             if dependency in standalone_modules_by_name:
-                print "ERROR: Standalone module %s may not be present among the dependencies of %s" % (dependency, module["name"])
+                log_error("Standalone module '%s' may not be present among the dependencies of '%s'" % (dependency, module["name"]))
                 errors_found = True
 
 verify_standalone_modules()
 
 
 def check_duplicate_files():
 
     def check_module(module, seen_files, seen_modules):
         name = module["name"]
         seen_modules[name] = True
         for dep_name in module["dependencies"]:
             if not dep_name in seen_modules:
                 check_module(modules_by_name[dep_name], seen_files, seen_modules)
         for source in module["sources"]:
             referencing_module = seen_files.get(source)
             if referencing_module:
-                print "ERROR: Duplicate use of %s in '%s' (previously seen in '%s')" % (source, name, referencing_module)
+                log_error("Duplicate use of %s in '%s' (previously seen in '%s')" % (source, name, referencing_module))
             seen_files[source] = name
 
     for module_name in standalone_modules_by_name:
         check_module(standalone_modules_by_name[module_name], {}, {})
 
 print "Checking duplicate files across modules..."
 check_duplicate_files()
 
 
 def module_arg(module_name):
@@ skipping 161 matching lines @@
 errors_found |= hasErrors(validateInjectedScriptOut)
 
 if errors_found:
     print "ERRORS DETECTED"
 
 os.remove(injectedScriptSourceTmpFile)
 os.remove(injectedScriptCanvasModuleSourceTmpFile)
 os.remove(compiler_args_file.name)
 os.remove(protocol_externs_file)
 shutil.rmtree(modules_dir, True)