[DevTools] Remove handlers = browser from protocol definition.

chrome/browser/devtools/devtools_protocol_constants_generator.py

 #!/usr/bin/python
 # Copyright 2014 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 sys
 import string
 import json
 
 package = sys.argv[1]
@@ skipping 64 matching lines @@
 const char kResult[] = "result";
 $contents
 
 }  // devtools
 }  // $package
 """)
 
 def Capitalize(s):
   return s[:1].capitalize() + s[1:]
 
+def ToIdentifier(s):
+  return "".join([Capitalize(part) for part in s.split("-")])
+
 references = []
 
 def CreateNamespace(domain_name, data, keys, prefixes, name = None):
   result = {}
   if name:
     result["kName"] = name
   for i, key in enumerate(keys):
     if key in data:
       for parameter in data[key]:
         parameter_name = parameter["name"];
         result[prefixes[i] + Capitalize(parameter_name)] = parameter_name
         if "enum" in parameter:
           enum_name = Capitalize(parameter_name)
           result[enum_name] = {}
           for enum in parameter["enum"]:
-            result[enum_name]["kEnum" + Capitalize(enum)] = enum
+            result[enum_name]["kEnum" + ToIdentifier(enum)] = enum
         reference = ""
         if "$ref" in parameter:
           reference = parameter["$ref"]
         if "items" in parameter and "$ref" in parameter["items"]:
           reference = parameter["items"]["$ref"]
         if reference:
           if not "." in reference:
             reference = domain_name + "." + reference
           references.append(reference)
   return result
 
-def IsHandledInBrowser(item):
-  return "handlers" in item and "browser" in item["handlers"]
-
 def FormatContents(tree, indent, format_string):
   outer = dict((key, value) for key, value in tree.iteritems()
                 if not isinstance(value, dict))
   inner = dict((key, value) for key, value in tree.iteritems()
               if isinstance(value, dict))
   body = ""
   body += "".join(indent + format_string.format(key, value)
                  for (key, value) in sorted(outer.items()))
   body += "".join(FormatNamespace(key, value, indent, format_string)
                  for (key, value) in sorted(inner.items()))
@@ skipping 30 matching lines @@
 
 domains = blink_protocol["domains"]
 
 namespace_tree = {}
 
 for domain in domains:
   domain_value = {}
   domain_namespace_name = Capitalize(domain["domain"])
   if "commands" in domain:
     for command in domain["commands"]:
-      if (IsHandledInBrowser(command)):
-        domain_value[command["name"]] = CreateNamespace(domain["domain"],
-            command, ["parameters", "returns"], ["kParam", "kResponse"],
-            domain_namespace_name + "." + command["name"])
+      domain_value[command["name"]] = CreateNamespace(domain["domain"],
+          command, ["parameters", "returns"], ["kParam", "kResponse"],
+          domain_namespace_name + "." + command["name"])
 
   if "events" in domain:
     for event in domain["events"]:
-      if IsHandledInBrowser(event):
-        domain_value[event["name"]] = CreateNamespace(domain["domain"],
-            event, ["parameters"], ["kParam"],
-            domain_namespace_name + "." + event["name"])
+      domain_value[event["name"]] = CreateNamespace(domain["domain"],
+          event, ["parameters"], ["kParam"],
+          domain_namespace_name + "." + event["name"])
   if domain_value:
     namespace_tree[domain_namespace_name] = domain_value
 
 while (references):
   reference = references.pop();
   path = reference.split(".");
   parent_namespace = namespace_tree;
   for path_segment in path[0:-1]:
     if path_segment not in parent_namespace:
       parent_namespace[path_segment] = {}
     parent_namespace = parent_namespace[path_segment]
   if (path[-1] not in parent_namespace):
     try:
       domain = [d for d in domains if d["domain"] == path[0]][0]
       ref_type = [t for t in domain["types"] if t["id"] == path[1]][0]
       parent_namespace[ref_type["id"]] = CreateNamespace(path[0],
           ref_type, ["properties"], ["kParam"])
     except IndexError:
       sys.stderr.write("Failed to resolve type [{0}].\n".format(reference))
       sys.exit(1)
 
 for (namespace_name, namespace) in namespace_tree.items():
   namespace["kName"] = namespace_name
 
 with open(output_cc_path, "w") as f:
   CreateBody(namespace_tree, blink_version, f)
 
 with open(output_h_path, "w") as f:
   CreateHeader(namespace_tree, f)