Updated to Chrome 45 (2454) moved from SVN to git.

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
@@ skipping 86 matching lines @@
 
 template_outofline = string.Template("""
 ${return_type} ${name}Impl(${params_impl})
 {${impl_lines}
 }""")
 
 template_agent_call = string.Template("""
     if (${agent_class}* agent = ${agent_fetch})
         ${maybe_return}agent->${name}(${params_agent});""")
 
-template_agent_call_timeline_returns_cookie = string.Template("""
-    int timelineAgentId = 0;
-    if (InspectorTimelineAgent* agent = agents->inspectorTimelineAgent()) {
-        if (agent->${name}(${params_agent}))
-            timelineAgentId = agent->id();
-    }""")
-
-
 template_instrumenting_agents_h = string.Template("""// Code generated from InspectorInstrumentation.idl
 
 #ifndef InstrumentingAgentsInl_h
 #define InstrumentingAgentsInl_h
 
+#include "core/CoreExport.h"
 #include "platform/heap/Handle.h"
 #include "wtf/FastAllocBase.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 
 namespace blink {
 
 ${forward_list}
 
-class InstrumentingAgents : public RefCountedWillBeGarbageCollectedFinalized<InstrumentingAgents> {
+class CORE_EXPORT InstrumentingAgents : public RefCountedWillBeGarbageCollectedFinalized<InstrumentingAgents> {
     WTF_MAKE_NONCOPYABLE(InstrumentingAgents);
-    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(InstrumentingAgents);
 public:
     static PassRefPtrWillBeRawPtr<InstrumentingAgents> create()
     {
         return adoptRefWillBeNoop(new InstrumentingAgents());
     }
     ~InstrumentingAgents() { }
-    void trace(Visitor*);
+    DECLARE_TRACE();
     void reset();
 
 ${accessor_list}
 
 private:
     InstrumentingAgents();
 
 ${member_list}
 };
 
 }
 
 #endif // !defined(InstrumentingAgentsInl_h)
 """)
 
 template_instrumenting_agent_accessor = string.Template("""
     ${class_name}* ${getter_name}() const { return ${member_name}; }
     void set${class_name}(${class_name}* agent) { ${member_name} = agent; }""")
 
 template_instrumenting_agents_cpp = string.Template("""
 InstrumentingAgents::InstrumentingAgents()
     : $init_list
 {
 }
 
-void InstrumentingAgents::trace(Visitor* visitor)
+DEFINE_TRACE(InstrumentingAgents)
 {
     $trace_list
 }
 
 void InstrumentingAgents::reset()
 {
     $reset_list
 }""")
 
 
@@ skipping 101 matching lines @@
             if not "Keep" in self.params_impl[0].options:
                 self.params_impl = self.params_impl[1:]
             self.params_impl = [Parameter("InstrumentingAgents* agents")] + self.params_impl
 
         self.agents = filter(lambda option: not "=" in option, self.options)
 
     def generate_header(self, header_lines):
         if "Inline=Custom" in self.options:
             return
 
-        header_lines.append("%s %sImpl(%s);" % (
+        header_lines.append("CORE_EXPORT %s %sImpl(%s);" % (
             self.return_type, self.name, ", ".join(map(Parameter.to_str_class, self.params_impl))))
 
         if "Inline=FastReturn" in self.options or "Inline=Forward" in self.options:
             fast_return = "\n    FAST_RETURN_IF_NO_FRONTENDS(%s);" % self.default_return_value
         else:
             fast_return = ""
 
         for param in self.params:
             if "FastReturn" in param.options:
                 fast_return += "\n    if (!%s)\n        return %s;" % (param.name, self.default_return_value)
@@ skipping 23 matching lines @@
             condition=condition))
 
     def generate_cpp(self, cpp_lines):
         if len(self.agents) == 0:
             return
 
         body_lines = map(self.generate_ref_ptr, self.params)
         body_lines += map(self.generate_agent_call, self.agents)
 
         if self.returns_cookie:
-            if "Timeline" in self.agents:
-                timeline_agent_id = "timelineAgentId"
-            else:
-                timeline_agent_id = "0"
-            body_lines.append("\n    return InspectorInstrumentationCookie(agents, %s);" % timeline_agent_id)
+            body_lines.append("\n    return InspectorInstrumentationCookie(agents);")
         elif self.returns_value:
             body_lines.append("\n    return %s;" % self.default_return_value)
 
-        cpp_lines.append(template_outofline.substitute(
+        generated_outofline = template_outofline.substitute(
             None,
             return_type=self.return_type,
             name=self.name,
             params_impl=", ".join(map(Parameter.to_str_class_and_name, self.params_impl)),
-            impl_lines="".join(body_lines)))
+            impl_lines="".join(body_lines))
+        if generated_outofline not in cpp_lines:
+            cpp_lines.append(generated_outofline)
 
     def generate_agent_call(self, agent):
         agent_class, agent_getter = agent_getter_signature(agent)
 
         leading_param_name = self.params_impl[0].name
         if not self.accepts_cookie:
             agent_fetch = "%s->%s()" % (leading_param_name, agent_getter)
-        elif agent == "Timeline":
-            agent_fetch = "retrieveTimelineAgent(%s)" % leading_param_name
         else:
             agent_fetch = "%s.instrumentingAgents()->%s()" % (leading_param_name, agent_getter)
 
-        if agent == "Timeline" and self.returns_cookie:
-            template = template_agent_call_timeline_returns_cookie
-        else:
-            template = template_agent_call
+        template = template_agent_call
 
         if not self.returns_value or self.returns_cookie:
             maybe_return = ""
         else:
             maybe_return = "return "
 
         return template.substitute(
             None,
             name=self.name,
             agent_class=agent_class,
@@ skipping 62 matching lines @@
     def to_str_value(self):
         return self.value
 
 
 def generate_param_name(param_type):
     base_name = re.match("(const |PassRefPtr<)?(\w*)", param_type).group(2)
     return "param" + base_name
 
 
 def agent_class_name(agent):
-    custom_agent_names = ["PageDebugger", "PageRuntime", "WorkerRuntime"]
+    custom_agent_names = ["PageDebugger", "PageRuntime", "WorkerRuntime", "PageConsole"]
     if agent in custom_agent_names:
         return "%sAgent" % agent
+    if agent == "AsyncCallTracker":
+        return agent
     return "Inspector%sAgent" % agent
 
 
 def agent_getter_signature(agent):
     agent_class = agent_class_name(agent)
     return agent_class, agent_class[0].lower() + agent_class[1:]
 
 
 def include_header(name):
     return "#include \"%s.h\"" % name
@@ skipping 61 matching lines @@
     for f in files:
         cpp_includes.append(include_header(f.header_name))
 
         fout = open(output_dir + "/" + f.header_name + ".h", "w")
         fout.write(f.generate(cpp_lines, used_agents))
         fout.close()
 
     for agent in used_agents:
         cpp_includes.append(include_inspector_header(agent_class_name(agent)))
     cpp_includes.append(include_header("InstrumentingAgentsInl"))
+    cpp_includes.append(include_header("core/CoreExport"))
     cpp_includes.sort()
 
     instrumenting_agents_header, instrumenting_agents_cpp = generate_instrumenting_agents(used_agents)
 
     fout = open(output_dir + "/" + "InstrumentingAgentsInl.h", "w")
     fout.write(instrumenting_agents_header)
     fout.close()
 
     fout = open(output_dir + "/InspectorInstrumentationImpl.cpp", "w")
     fout.write(template_cpp.substitute(None,
@@ skipping 15 matching lines @@
     if not output_dirpath:
         raise Exception("Output 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> --output_dir <output_dir> InspectorInstrumentation.idl\n")
     exit(1)
 
 generate(input_path, output_dirpath)