Dartium Roll 38 roll

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 21 matching lines @@
 import string
 import sys
 
 template_h = string.Template("""// Code generated from InspectorInstrumentation.idl
 
 #ifndef ${file_name}_h
 #define ${file_name}_h
 
 ${includes}
 
-namespace WebCore {
+namespace blink {
+
+${forward_declarations}
 
 namespace InspectorInstrumentation {
 
 $methods
 } // namespace InspectorInstrumentation
 
-} // namespace WebCore
+} // namespace blink
 
 #endif // !defined(${file_name}_h)
 """)
 
 template_inline = string.Template("""
 inline void ${name}(${params_public})
 {   ${fast_return}
     if (${condition})
         ${name}Impl(${params_impl});
 }
@@ skipping 15 matching lines @@
 }
 """)
 
 
 template_cpp = string.Template("""// Code generated from InspectorInstrumentation.idl
 
 #include "config.h"
 
 ${includes}
 
-namespace WebCore {
+namespace blink {
 ${extra_definitions}
 
 namespace InspectorInstrumentation {
 $methods
 
 } // namespace InspectorInstrumentation
 
-} // namespace WebCore
+} // namespace blink
 """)
 
 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 "platform/heap/Handle.h"
 #include "wtf/FastAllocBase.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 
-namespace WebCore {
+namespace blink {
 
 ${forward_list}
 
-class InstrumentingAgents : public RefCounted<InstrumentingAgents> {
+class InstrumentingAgents : public RefCountedWillBeGarbageCollectedFinalized<InstrumentingAgents> {
     WTF_MAKE_NONCOPYABLE(InstrumentingAgents);
-    WTF_MAKE_FAST_ALLOCATED;
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
-    static PassRefPtr<InstrumentingAgents> create()
+    static PassRefPtrWillBeRawPtr<InstrumentingAgents> create()
     {
-        return adoptRef(new InstrumentingAgents());
+        return adoptRefWillBeNoop(new InstrumentingAgents());
     }
     ~InstrumentingAgents() { }
+    void trace(Visitor*);
     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)
+{
+    $trace_list
+}
+
 void InstrumentingAgents::reset()
 {
     $reset_list
 }""")
 
 
 
 def match_and_consume(pattern, source):
     match = re.match(pattern, source)
     if match:
@@ skipping 17 matching lines @@
         model.append(File(match.group(1), match.group(2)))
 
     return model
 
 
 class File:
     def __init__(self, name, source):
         self.name = name
         self.header_name = self.name + "Inl"
         self.includes = [include_inspector_header("InspectorInstrumentation")]
+        self.forward_declarations = []
         self.declarations = []
         for line in map(str.strip, source.split("\n")):
             line = re.sub("\s{2,}", " ", line).strip()  # Collapse whitespace
             if len(line) == 0:
                 continue
             if line[0] == "#":
                 self.includes.append(line)
+            elif line.startswith("class "):
+                self.forward_declarations.append(line)
             else:
                 self.declarations.append(Method(line))
         self.includes.sort()
+        self.forward_declarations.sort()
 
     def generate(self, cpp_lines, used_agents):
         header_lines = []
         for declaration in self.declarations:
             for agent in set(declaration.agents):
                 used_agents.add(agent)
             declaration.generate_header(header_lines)
             declaration.generate_cpp(cpp_lines)
 
         return template_h.substitute(None,
                                      file_name=self.header_name,
                                      includes="\n".join(self.includes),
+                                     forward_declarations="\n".join(self.forward_declarations),
                                      methods="\n".join(header_lines))
 
 
 class Method:
     def __init__(self, source):
         match = re.match("(\[[\w|,|=|\s]*\])?\s?(\w*\*?) (\w*)\((.*)\)\s?;", source)
         if not match:
             sys.stderr.write("Cannot parse %s\n" % source)
             sys.exit(1)
 
@@ skipping 10 matching lines @@
         # Splitting parameters by a comma, assuming that attribute lists contain no more than one attribute.
         self.params = map(Parameter, map(str.strip, match.group(4).split(",")))
 
         self.accepts_cookie = len(self.params) and self.params[0].type == "const InspectorInstrumentationCookie&"
         self.returns_cookie = self.return_type == "InspectorInstrumentationCookie"
 
         self.returns_value = self.return_type != "void"
 
         if self.return_type == "bool":
             self.default_return_value = "false"
+        elif self.return_type == "int":
+            self.default_return_value = "0"
         elif self.return_type == "String":
             self.default_return_value = "\"\""
         else:
             self.default_return_value = self.return_type + "()"
 
         for param in self.params:
             if "DefaultReturn" in param.options:
                 self.default_return_value = param.name
 
         self.params_impl = self.params
@@ skipping 173 matching lines @@
     return include_header("core/inspector/" + name)
 
 
 def generate_instrumenting_agents(used_agents):
     agents = list(used_agents)
 
     forward_list = []
     accessor_list = []
     member_list = []
     init_list = []
+    trace_list = []
     reset_list = []
 
     for agent in agents:
         class_name, getter_name = agent_getter_signature(agent)
         member_name = "m_" + getter_name
 
         forward_list.append("class %s;" % class_name)
         accessor_list.append(template_instrumenting_agent_accessor.substitute(
             None,
             class_name=class_name,
             getter_name=getter_name,
             member_name=member_name))
-        member_list.append("    %s* %s;" % (class_name, member_name))
-        init_list.append("%s(0)" % member_name)
-        reset_list.append("%s = 0;" % member_name)
+        member_list.append("    RawPtrWillBeMember<%s> %s;" % (class_name, member_name))
+        init_list.append("%s(nullptr)" % member_name)
+        trace_list.append("visitor->trace(%s);" % member_name)
+        reset_list.append("%s = nullptr;" % member_name)
 
     forward_list.sort()
     accessor_list.sort()
     member_list.sort()
     init_list.sort()
+    trace_list.sort()
     reset_list.sort()
 
     header_lines = template_instrumenting_agents_h.substitute(
         None,
         forward_list="\n".join(forward_list),
         accessor_list="\n".join(accessor_list),
         member_list="\n".join(member_list))
 
     cpp_lines = template_instrumenting_agents_cpp.substitute(
         None,
         init_list="\n    , ".join(init_list),
+        trace_list="\n    ".join(trace_list),
         reset_list="\n    ".join(reset_list))
 
     return header_lines, cpp_lines
 
 
 def generate(input_path, output_dir):
     fin = open(input_path, "r")
     files = load_model_from_idl(fin.read())
     fin.close()
 
@@ skipping 38 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)