[instrumentation] Rename InspectorInstrumentation into CoreProbes

third_party/WebKit/Source/platform/probe/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
 # Paths have to be normalized because Jinja uses the exact template path to
 # determine the hash used in the cache filename, and we need a pre-caching step
 # to be concurrency-safe. Use absolute path because __file__ is absolute if
 # module is imported, and relative if executed directly.
 # If paths differ between pre-caching and individual file compilation, the cache
 # is regenerated, which causes a race condition and breaks concurrent build,
 # since some compile processes will try to read the partially written cache.
 module_path, module_filename = os.path.split(os.path.realpath(__file__))
-templates_dir = module_path
+templates_dir = os.path.join(module_path, "templates")
 third_party_dir = os.path.normpath(os.path.join(
     module_path, os.pardir, os.pardir, os.pardir, os.pardir))
 # jinja2 is in chromium's third_party directory.
 # Insert at 1 so at front to override system libraries, and
 # after path[0] == invoking script dir
 sys.path.insert(1, third_party_dir)
 import jinja2
 
 
+def to_singular(text):
+    return text[:-1] if text[-1] == "s" else text
+
+
 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),
         keep_trailing_newline=True,  # newline-terminate generated files
         lstrip_blocks=True,  # so can indent control flow tags
         trim_blocks=True)
     jinja_env.filters.update({
         "to_lower_case": to_lower_case,
+        "to_singular": to_singular,
         "agent_name_to_class": agent_name_to_class})
     jinja_env.add_extension('jinja2.ext.loopcontrols')
     return jinja_env
 
 
 def match_and_consume(pattern, source):
     match = re.match(pattern, source)
     if match:
         return match, source[len(match.group(0)):].strip()
     return None, source
@@ skipping 38 matching lines @@
         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)
+    if name == "PlatformProbes":
+        return include_header("platform/probe/" + name)
+    if name == "CoreProbes":
+        return include_header("core/probe/" + 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 96 matching lines @@
             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_template = jinja_env.get_template("/InstrumentingProbesImpl.cpp.tmpl")
 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 + "/" + base_name + "Agents.h", "w")
-agents_h_file.write(agents_h_template.render(template_context))
-agents_h_file.close()
+sink_h_template = jinja_env.get_template("/ProbeSink.h.tmpl")
+sink_h_file = open(output_dirpath + "/" + to_singular(base_name) + "Sink.h", "w")
+sink_h_file.write(sink_h_template.render(template_context))
+sink_h_file.close()
 
 for f in files:
     template_context["file"] = f
-    h_template = jinja_env.get_template("/InstrumentingProbesImpl_h.template")
+    h_template = jinja_env.get_template("/InstrumentingProbesInl.h.tmpl")
     h_file = open(output_dirpath + "/" + f.header_name + ".h", "w")
     h_file.write(h_template.render(template_context))
     h_file.close()