[instrumentation] Generalize instrumentation to be used beyond the core layer

third_party/WebKit/Source/platform/instrumentation/InstrumentingProbesCodeGenerator.py

 # Copyright 2017 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.
 
 import optparse
 import os.path
 import re
 import sys
 
 # Path handling for libraries and templates
@@ skipping 17 matching lines @@
 
 def to_lower_case(name):
     return name[:1].lower() + name[1:]
 
 
 def agent_name_to_class(agent_name):
     if agent_name == "Performance":
         return "PerformanceMonitor"
     elif agent_name == "TraceEvents":
         return "InspectorTraceEvents"
+    elif agent_name == "PlatformTraceEvents":
+        return "PlatformTraceEventsAgent"
     else:
         return "Inspector%sAgent" % agent_name
 
 
 def initialize_jinja_env(cache_dir):
     jinja_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(templates_dir),
         # Bytecode cache is not concurrency-safe unless pre-cached:
         # if pre-cached this is read-only, but writing creates a race condition.
         bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir),
@@ skipping 26 matching lines @@
             sys.stderr.write("Cannot parse %s\n" % source[:100])
             sys.exit(1)
         model.append(File(match.group(1), match.group(2)))
     return model
 
 
 class File(object):
     def __init__(self, name, source):
         self.name = name
         self.header_name = self.name + "Inl"
-        self.includes = [include_inspector_header("InspectorInstrumentation")]
+        self.includes = [include_inspector_header(base_name)]
         self.forward_declarations = []
         self.declarations = []
+        self.defines = []
         for line in map(str.strip, source.split("\n")):
             line = re.sub(r"\s{2,}", " ", line).strip()  # Collapse whitespace
             if len(line) == 0:
                 continue
-            if line[0] == "#":
+            if line.startswith("#define"):
+                self.defines.append(line)
+            elif line.startswith("#include"):
                 self.includes.append(line)
-            elif line.startswith("class "):
+            elif line.startswith("class ") or line.startswith("struct "):
                 self.forward_declarations.append(line)
             else:
                 self.declarations.append(Method(line))
         self.includes.sort()
         self.forward_declarations.sort()
 
 
 def include_header(name):
     return "#include \"%s.h\"" % name
 
 
 def include_inspector_header(name):
     if name == "PerformanceMonitor":
         return include_header("core/frame/" + name)
+    if name == "PlatformInstrumentation":
+        return include_header("platform/instrumentation/" + name)
     return include_header("core/inspector/" + name)
 
 
 class Method(object):
     def __init__(self, source):
         match = re.match(r"(\[[\w|,|=|\s]*\])?\s?(\w*\*?) (\w*)\((.*)\)\s?;", source)
         if not match:
             sys.stderr.write("Cannot parse %s\n" % source)
             sys.exit(1)
 
@@ skipping 75 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> InstrumentingProbes.idl\n")
     exit(1)
 
 jinja_env = initialize_jinja_env(output_dirpath)
+all_agents = set()
+all_defines = []
+base_name = os.path.splitext(os.path.basename(input_path))[0]
+
 fin = open(input_path, "r")
 files = load_model_from_idl(fin.read())
 fin.close()
-all_agents = set()
 
 for f in files:
     for declaration in f.declarations:
         for agent in declaration.agents:
             all_agents.add(agent)
+    all_defines += f.defines
 
 template_context = {
     "files": files,
     "agents": all_agents,
+    "defines": all_defines,
+    "name": base_name,
     "input_file": os.path.basename(input_path)
 }
 cpp_template = jinja_env.get_template("/InstrumentingProbesImpl_cpp.template")
-cpp_file = open(output_dirpath + "/InstrumentingProbesImpl.cpp", "w")
+cpp_file = open(output_dirpath + "/" + base_name + "Impl.cpp", "w")
 cpp_file.write(cpp_template.render(template_context))
 cpp_file.close()
 
 agents_h_template = jinja_env.get_template("/InstrumentingAgents_h.template")
-agents_h_file = open(output_dirpath + "/InstrumentingAgents.h", "w")
+agents_h_file = open(output_dirpath + "/" + base_name + "Agents.h", "w")
 agents_h_file.write(agents_h_template.render(template_context))
 agents_h_file.close()
 
 for f in files:
     template_context["file"] = f
     h_template = jinja_env.get_template("/InstrumentingProbesImpl_h.template")
-    h_file = open(output_dirpath + "/" + f.name + "Inl.h", "w")
+    h_file = open(output_dirpath + "/" + f.header_name + ".h", "w")
     h_file.write(h_template.render(template_context))
     h_file.close()