Forgotten new files.

core/inspector/CodeGeneratorInstrumentation.py

+#!/usr/bin/env python
+# Copyright (c) 2013 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
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import optparse
+import re
+import string
+import sys
+
+template_h = string.Template("""// Code generated from InspectorInstrumentation.idl
+
+#ifndef InspectorInstrumentationInl_h
+#define InspectorInstrumentationInl_h
+
+namespace WebCore {
+
+namespace InspectorInstrumentation {
+
+$impl_declarations
+$inline_methods
+} // namespace InspectorInstrumentation
+
+} // namespace WebCore
+
+#endif // !defined(InspectorInstrumentationInl_h)
+""")
+
+template_inline = string.Template("""
+inline void ${name}(${params_public})
+{   ${fast_return}
+    if (InstrumentingAgents* instrumentingAgents = ${agents_getter})
+        ${name}Impl(${params_impl});
+}
+""")
+
+template_inline_forward = string.Template("""
+inline void ${name}(${params_public})
+{   ${fast_return}
+    ${name}Impl(${params_impl});
+}
+""")
+
+template_inline_accepts_cookie = string.Template("""
+inline void ${name}(${params_public})
+{   ${fast_return}
+    if (${cookie}.isValid())
+        ${name}Impl(${params_impl});
+}
+""")
+
+template_inline_returns_cookie = string.Template("""
+inline InspectorInstrumentationCookie ${name}(${params_public})
+{   ${fast_return}
+    if (InstrumentingAgents* instrumentingAgents = ${agents_getter})
+        return ${name}Impl(${params_impl});
+    return InspectorInstrumentationCookie();
+}
+""")
+
+
+template_cpp = string.Template("""// Code generated from InspectorInstrumentation.idl
+
+#include "config.h"
+#include "core/inspector/InspectorInstrumentation.h"
+
+#include "core/inspector/InspectorAgent.h"
+#include "core/inspector/InspectorApplicationCacheAgent.h"
+#include "core/inspector/InspectorCSSAgent.h"
+#include "core/inspector/InspectorCanvasAgent.h"
+#include "core/inspector/InspectorConsoleAgent.h"
+#include "core/inspector/InspectorConsoleInstrumentation.h"
+#include "core/inspector/InspectorDOMAgent.h"
+#include "core/inspector/InspectorDOMDebuggerAgent.h"
+#include "core/inspector/InspectorDOMStorageAgent.h"
+#include "core/inspector/InspectorDatabaseAgent.h"
+#include "core/inspector/InspectorDatabaseInstrumentation.h"
+#include "core/inspector/InspectorDebuggerAgent.h"
+#include "core/inspector/InspectorHeapProfilerAgent.h"
+#include "core/inspector/InspectorLayerTreeAgent.h"
+#include "core/inspector/InspectorPageAgent.h"
+#include "core/inspector/InspectorProfilerAgent.h"
+#include "core/inspector/InspectorResourceAgent.h"
+#include "core/inspector/InspectorTimelineAgent.h"
+#include "core/inspector/InspectorWorkerAgent.h"
+#include "core/inspector/InstrumentingAgents.h"
+#include "core/inspector/PageDebuggerAgent.h"
+#include "core/inspector/PageRuntimeAgent.h"
+#include "core/inspector/WorkerRuntimeAgent.h"
+
+namespace WebCore {
+
+namespace InspectorInstrumentation {
+$out_of_line_methods
+
+} // namespace InspectorInstrumentation
+
+} // namespace WebCore
+""")
+
+template_outofline = string.Template("""
+void ${name}Impl(${params_impl})
+{${agent_calls}
+}""")
+
+template_agent_call = string.Template("""
+    if (${agent_class}* ${agent}Agent = ${agent_fetch})
+        ${agent}Agent->${name}(${params_agent});""")
+
+template_timeline_agent_call = string.Template("""
+    int timelineAgentId = 0;
+    if (InspectorTimelineAgent* timelineAgent = instrumentingAgents->inspectorTimelineAgent()) {
+        if (timelineAgent->${name}(${params_agent}))
+            timelineAgentId = timelineAgent->id();
+    }""")
+
+template_outofline_returns_cookie = string.Template("""
+${return_type} ${name}Impl(${params_impl})
+{${agent_calls}
+    return InspectorInstrumentationCookie(instrumentingAgents, ${timeline_agent_id});
+}""")
+
+
+def load_model_from_idl(source):
+    source = re.sub("//.*\n", "", source)    # Remove line comments
+    source = re.sub("\n", " ", source)       # Remove newlines
+    source = re.sub("/\*.*\*/", "", source)  # Remove block comments
+    source = re.sub("\s\s+", " ", source)    # Collapse whitespace
+    source = source.strip()
+
+    match = re.match("interface\s\w*\s?\{(.*)\}", source)
+    if not match:
+        sys.stderr.write("Cannot parse the file")
+        sys.exit(1)
+    lines = match.group(1)
+
+    methods = []
+    for line in map(str.strip, lines.split(";")):
+        if len(line) == 0:
+            continue
+        methods.append(Method(line))
+    return methods
+
+
+class Method:
+    def __init__(self, source):
+        match = re.match("(\[[\w|,|=|\s]*\])?\s?(\w*) (\w*)\((.*)\)", source)
+        if not match:
+            sys.stderr.write("Cannot parse %s\n" % source)
+            sys.exit(1)
+
+        self.method_options = []
+        if match.group(1):
+            method_options_str = re.sub("\s", "", match.group(1)[1:-1])
+            if len(method_options_str) != 0:
+                self.method_options = method_options_str.split(",")
+
+        self.return_type = match.group(2)
+
+        self.name = match.group(3)
+
+        param_string = match.group(4)
+
+        self.param_options = []
+        options_match = re.match("\[(.*)\]\s?(.*)", param_string)
+        if options_match:
+            param_string = options_match.group(2)
+            self.param_options = map(str.strip, options_match.group(1).split(","))
+
+        self.params = map(Parameter, map(str.strip, param_string.split(",")))
+
+
+class Parameter:
+    def __init__(self, source):
+        parts = map(str.strip, source.split("="))
+        if len(parts) == 1:
+            self.default_value = None
+        else:
+            self.default_value = parts[1]
+
+        param_decl = parts[0]
+
+        if re.match("(const|unsigned long) ", param_decl):
+            min_type_tokens = 2
+        else:
+            min_type_tokens = 1
+
+        if len(param_decl.split(" ")) > min_type_tokens:
+            parts = param_decl.split(" ")
+            self.type = " ".join(parts[:-1])
+            self.name = parts[-1]
+        else:
+            self.type = param_decl
+            self.name = generate_param_name(self.type)
+
+    def to_str_full(self):
+        if self.default_value is None:
+            return self.to_str_class_and_name()
+        return "%s %s = %s" % (self.type, self.name, self.default_value)
+
+    def to_str_class_and_name(self):
+        return "%s %s" % (self.type, self.name)
+
+    def to_str_class(self):
+        return self.type
+
+    def to_str_name(self):
+        return self.name
+
+
+# This function is only needed to minimize the diff with the handwritten code.
+# In fact it is sufficient to return a globally unique string.
+def generate_param_name(param_type):
+    base_name = re.match("(const |RefPtr<|PassRefPtr<)?(\w*)", param_type).group(2)
+
+    custom_param_types = {
+        "CharacterData": "characterData",
+        "CSSSelector": "pseudoState",
+        "DocumentStyleSheetCollection": "styleSheetCollection",
+        "EventPath": "eventPath",
+        "FormData": "formData",
+        "InspectorCSSOMWrappers": "inspectorCSSOMWrappers",
+        "InstrumentingAgents": "instrumentingAgents",
+        "NamedFlow": "namedFlow",
+        "RenderObject": "renderer",
+        "RenderLayer": "renderLayer",
+        "ResourceLoader": "resourceLoader",
+        "PseudoElement": "pseudoElement",
+        "ScriptState": "scriptState"}
+    if base_name in custom_param_types:
+        return custom_param_types[base_name]
+
+    match = re.match("(.*)([A-Z][a-z]+)", base_name)
+    if match:
+        return match.group(2).lower()  # CamelCaseWord -> word
+
+    if base_name.lower() == base_name:
+        return base_name + "_"
+    return base_name.lower()
+
+
+# This function is only needed to minimize the diff with the handwritten code.
+# In fact is is sufficient to hardcode a constant string (e.g. "agent") into the template.
+def agent_variable_name(agent):
+    if re.match("DOM", agent):
+        return re.sub("DOM", "dom", agent)
+    if agent.upper() == agent:
+        return agent.lower()
+    return agent[0].lower() + agent[1:]
+
+
+def agent_class_name(agent):
+    custom_agent_names = ["Inspector", "PageDebugger", "PageRuntime", "WorkerRuntime"]
+    if agent in custom_agent_names:
+        return "%sAgent" % agent
+    return "Inspector%sAgent" % agent
+
+
+def agent_getter_name(agent):
+    name = agent_class_name(agent)
+    return name[0].lower() + name[1:]
+
+
+def generate(input_path, output_h_dir, output_cpp_dir):
+    fin = open(input_path, "r")
+    declarations = load_model_from_idl(fin.read())
+    fin.close()
+
+    impl_declarations = []
+    inline_methods = []
+    out_of_line_methods = []
+
+    for declaration in declarations:
+        param_string_public = ", ".join(map(Parameter.to_str_full, declaration.params))
+
+        param_list_impl_parsed = declaration.params[:]
+
+        accepts_cookie = (declaration.params[0].type == "const InspectorInstrumentationCookie&")
+        if not accepts_cookie and not "Inline=Forward" in declaration.method_options:
+            if not "Keep" in declaration.param_options:
+                param_list_impl_parsed = param_list_impl_parsed[1:]
+            param_list_impl_parsed = [Parameter("InstrumentingAgents*")] + param_list_impl_parsed
+
+        generate_inline = not "Inline=Custom" in declaration.method_options
+        if generate_inline:
+            impl_declarations.append("%s %sImpl(%s);" % (
+                declaration.return_type, declaration.name, ", ".join(map(Parameter.to_str_class, param_list_impl_parsed))))
+
+        leading_impl_param_name = param_list_impl_parsed[0].name
+        param_string_impl_full = ", ".join(map(Parameter.to_str_class_and_name, param_list_impl_parsed))
+
+        param_list_impl_names_only = map(Parameter.to_str_name, param_list_impl_parsed)
+        param_string_impl_names_only = ", ".join(param_list_impl_names_only)
+        param_string_agent = ", ".join(param_list_impl_names_only[1:])
+
+        def is_agent_name(name):
+            return not "=" in name
+
+        agents = filter(is_agent_name, declaration.method_options)
+
+        if "Inline=FastReturn" in declaration.method_options or "Inline=Forward" in declaration.method_options:
+            fast_return = "\n    FAST_RETURN_IF_NO_FRONTENDS(%s());" % declaration.return_type
+        else:
+            fast_return = ""
+
+        if accepts_cookie:
+            if generate_inline:
+                inline_methods.append(
+                    template_inline_accepts_cookie.substitute(
+                        None,
+                        name=declaration.name,
+                        fast_return=fast_return,
+                        params_public=param_string_public,
+                        params_impl=param_string_impl_names_only,
+                        cookie=leading_impl_param_name))
+            if len(agents):
+                agent_calls = []
+                for agent in agents:
+                    if agent == "Timeline":
+                        agent_fetch = "retrieveTimelineAgent(%s)" % leading_impl_param_name
+                    else:
+                        agent_fetch = "%s.instrumentingAgents()->%s()" % (leading_impl_param_name, agent_getter_name(agent))
+                    agent_calls.append(
+                        template_agent_call.substitute(
+                            None,
+                            name=declaration.name,
+                            agent_fetch=agent_fetch,
+                            params_agent=param_string_agent,
+                            agent_class=agent_class_name(agent),
+                            agent=agent_variable_name(agent)))
+                out_of_line_methods.append(
+                    template_outofline.substitute(
+                        None,
+                        name=declaration.name,
+                        params_impl=param_string_impl_full,
+                        agent_calls="".join(agent_calls)))
+        else:
+            leading_public_param = declaration.params[0]
+            selector_class = re.match("(\w*)", leading_public_param.type).group(1)
+            agents_getter = "instrumentingAgentsFor%s(%s)" % (selector_class, leading_public_param.name)
+            if declaration.return_type == "void":
+                if generate_inline:
+                    if "Inline=Forward" in declaration.method_options:
+                        inline_methods.append(
+                            template_inline_forward.substitute(
+                                None,
+                                name=declaration.name,
+                                fast_return=fast_return,
+                                params_public=param_string_public,
+                                params_impl=param_string_impl_names_only))
+                    else:
+                        inline_methods.append(
+                            template_inline.substitute(
+                                None,
+                                name=declaration.name,
+                                fast_return=fast_return,
+                                params_public=param_string_public,
+                                params_impl=param_string_impl_names_only,
+                                agents_getter=agents_getter))
+                if len(agents):
+                    agent_calls = []
+                    for agent in agents:
+                        agent_fetch = "%s->%s()" % (leading_impl_param_name, agent_getter_name(agent))
+                        agent_call = template_agent_call.substitute(
+                            None,
+                            name=declaration.name,
+                            agent_fetch=agent_fetch,
+                            params_agent=param_string_agent,
+                            agent_class=agent_class_name(agent),
+                            agent=agent_variable_name(agent))
+                        agent_calls.append(agent_call)
+                    out_of_line_methods.append(
+                        template_outofline.substitute(
+                            None,
+                            name=declaration.name,
+                            params_impl=param_string_impl_full,
+                            agent_calls="".join(agent_calls)))
+            elif declaration.return_type == "InspectorInstrumentationCookie":
+                if generate_inline:
+                    inline_methods.append(
+                        template_inline_returns_cookie.substitute(
+                            None,
+                            name=declaration.name,
+                            fast_return=fast_return,
+                            params_public=param_string_public,
+                            params_impl=param_string_impl_names_only,
+                            agents_getter=agents_getter))
+
+                if len(agents):
+                    timeline_agent_id = "0"
+                    agent_calls = []
+                    for agent in agents:
+                        if agent == "Timeline":
+                            agent_call = template_timeline_agent_call.substitute(
+                                None,
+                                name=declaration.name,
+                                params_agent=param_string_agent)
+                            timeline_agent_id = "timelineAgentId"
+                        else:
+                            agent_fetch = "%s->%s()" % (leading_impl_param_name, agent_getter_name(agent))
+                            agent_call = template_agent_call.substitute(
+                                None,
+                                name=declaration.name,
+                                agent_fetch=agent_fetch,
+                                params_agent=param_string_agent,
+                                agent_class=agent_class_name(agent),
+                                agent=agent_variable_name(agent))
+                        agent_calls.append(agent_call)
+
+                    out_of_line_methods.append(
+                        template_outofline_returns_cookie.substitute(
+                            None,
+                            return_type=declaration.return_type,
+                            name=declaration.name,
+                            params_impl=param_string_impl_full,
+                            agent_calls="".join(agent_calls),
+                            timeline_agent_id=timeline_agent_id))
+            else:
+                sys.stderr.write("Unsupported return type %s" % declaration.return_type)
+                sys.exit(1)
+
+    fout = open(output_h_dir + "/InspectorInstrumentationInl.h", "w")
+    fout.write(template_h.substitute(None,
+                                     impl_declarations="\n".join(impl_declarations),
+                                     inline_methods="".join(inline_methods)))
+    fout.close()
+
+    fout = open(output_cpp_dir + "/InspectorInstrumentationImpl.cpp", "w")
+    fout.write(template_cpp.substitute(None,
+                                       out_of_line_methods="\n".join(out_of_line_methods)))
+    fout.close()
+
+
+cmdline_parser = optparse.OptionParser()
+cmdline_parser.add_option("--output_h_dir")
+cmdline_parser.add_option("--output_cpp_dir")
+
+try:
+    arg_options, arg_values = cmdline_parser.parse_args()
+    if (len(arg_values) != 1):
+        raise Exception("Exactly one plain argument expected (found %s)" % len(arg_values))
+    input_path = arg_values[0]
+    output_header_dirpath = arg_options.output_h_dir
+    output_cpp_dirpath = arg_options.output_cpp_dir
+    if not output_header_dirpath:
+        raise Exception("Output .h directory must be specified")
+    if not output_cpp_dirpath:
+        raise Exception("Output .cpp directory must be specified")
+except Exception:
+    # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
+    exc = sys.exc_info()[1]
+    sys.stderr.write("Failed to parse command-line arguments: %s\n\n" % exc)
+    sys.stderr.write("Usage: <script> InspectorInstrumentation.idl --output_h_dir <output_header_dir> --output_cpp_dir <output_cpp_dir>\n")
+    exit(1)
+
+generate(input_path, output_header_dirpath, output_cpp_dirpath)