[instrumentation]: Move probe subscriptions to JSON5 config file from PIDL.

third_party/WebKit/Source/build/scripts/make_instrumenting_probes.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 ast
 import optparse
 import os.path
 import re
 import sys
 
@@ skipping 85 matching lines @@
     model = []
     while len(source):
         match, source = match_and_consume(r"interface\s(\w*)\s?\{([^\{]*)\}", source)
         if not match:
             sys.stderr.write("Cannot parse %s\n" % source[:100])
             sys.exit(1)
         model.append(File(match.group(1), match.group(2)))
     return model
 
 
+def include_probes_header():
+    return "#include \"%s\"" % config["settings"]["probes_header"]
+
+
 class File(object):
     def __init__(self, name, source):
         self.name = name
         self.header_name = self.name + "Inl"
-        self.includes = [include_inspector_header(base_name)]
+        self.includes = [include_probes_header()]
         self.forward_declarations = []
         self.declarations = []
         for line in map(str.strip, source.split("\n")):
             line = re.sub(r"\s{2,}", " ", line).strip()  # Collapse whitespace
             if len(line) == 0:
                 continue
             elif line.startswith("#include"):
                 self.includes.append(line)
             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 == "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)
+        match = re.match(r"(?:(\w+\*?)\s+)?(\w+)\s*\((.*)\)\s*;", source)
         if not match:
             sys.stderr.write("Cannot parse %s\n" % source)
             sys.exit(1)
 
-        self.options = []
-        if match.group(1):
-            options_str = re.sub(r"\s", "", match.group(1)[1:-1])
-            if len(options_str) != 0:
-                self.options = options_str.split(",")
-
-        self.return_type = match.group(2)
-        self.name = match.group(3)
+        self.return_type = match.group(1) or ""
+        self.name = match.group(2)
         self.is_scoped = self.return_type == ""
 
         # 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.params = map(Parameter, map(str.strip, match.group(3).split(",")))
 
         self.returns_value = self.return_type != "" and self.return_type != "void"
         if self.return_type == "bool":
             self.default_return_value = "false"
         elif self.returns_value:
             sys.stderr.write("Can only return bool: %s\n" % self.name)
             sys.exit(1)
 
-        self.agents = [option for option in self.options if "=" not in option]
-
-        if self.returns_value and len(self.agents) > 1:
-            sys.stderr.write("Can only return value from a single agent: %s\n" % self.name)
-            sys.exit(1)
-
 
 class Parameter(object):
     def __init__(self, source):
         self.options = []
         match, source = match_and_consume(r"\[(\w*)\]", source)
         if match:
             self.options.append(match.group(1))
 
         parts = map(str.strip, source.split("="))
         self.default_value = parts[1] if len(parts) != 1 else None
@@ skipping 30 matching lines @@
     default_config = {
         "settings": {},
         "observers": {}
     }
     if not file_name:
         return default_config
     with open(file_name) as config_file:
         return _json5_loads(config_file.read()) or default_config
 
 
+def build_observers():
+    all_pidl_probes = set()
+    for f in files:
+        probes = set([probe.name for probe in f.declarations])
+        if all_pidl_probes & probes:
+            raise Exception("Multiple probe declarations: %s" % all_pidl_probes & probes)
+        all_pidl_probes |= probes
+
+    all_observers = set()
+    observers_by_probe = {}
+    unused_probes = set(all_pidl_probes)
+    for observer_name in config["observers"]:
+        all_observers.add(observer_name)
+        observer = config["observers"][observer_name]
+        for probe in observer["probes"]:
+            unused_probes.discard(probe)
+            if probe not in all_pidl_probes:
+                raise Exception('Probe %s is not declared in PIDL file' % probe)
+            if probe not in observers_by_probe:
+                observers_by_probe[probe] = set()
+            observers_by_probe[probe].add(observer_name)
+    if unused_probes:
+        raise Exception("Unused probes: %s" % unused_probes)
+
+    for f in files:
+        for probe in f.declarations:
+            probe.agents = observers_by_probe[probe.name]
+            if probe.returns_value and len(probe.agents) > 1:
+                raise Exception("Can only return value from a single observer: %s\n" % probe.name)
+    return all_observers
+
+
 cmdline_parser = optparse.OptionParser()
 cmdline_parser.add_option("--output_dir")
 cmdline_parser.add_option("--config")
 
 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_dirpath = arg_options.output_dir
     if not output_dirpath:
         raise Exception("Output directory must be specified")
     config_file_name = arg_options.config
 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> [options] <probes.pidl>\n")
     sys.stderr.write("Options:\n")
     sys.stderr.write("\t--config <config_file.json5>\n")
     sys.stderr.write("\t--output_dir <output_dir>\n")
     exit(1)
 
 config = load_config(config_file_name)
 jinja_env = initialize_jinja_env(output_dirpath)
-all_agents = set()
 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()
 
-for f in files:
-    for declaration in f.declarations:
-        for agent in declaration.agents:
-            all_agents.add(agent)
-
 template_context = {
     "files": files,
-    "agents": all_agents,
+    "agents": build_observers(),
     "config": config,
     "name": base_name,
     "input_file": os.path.basename(input_path)
 }
 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()
 
 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("/InstrumentingProbesInl.h.tmpl")
     h_file = open(output_dirpath + "/" + f.header_name + ".h", "w")
     h_file.write(h_template.render(template_context))
     h_file.close()