OLD | NEW |
1 #!/usr/bin/python | 1 #!/usr/bin/python |
2 # Copyright 2014 The Chromium Authors. All rights reserved. | 2 # Copyright 2014 The Chromium Authors. All rights reserved. |
3 # Use of this source code is governed by a BSD-style license that can be | 3 # Use of this source code is governed by a BSD-style license that can be |
4 # found in the LICENSE file. | 4 # found in the LICENSE file. |
5 | 5 |
6 import sys | 6 import sys |
7 import string | 7 import string |
8 import json | 8 import json |
9 | 9 |
10 package = sys.argv[1] | 10 package = sys.argv[1] |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
75 const char kResult[] = "result"; | 75 const char kResult[] = "result"; |
76 $contents | 76 $contents |
77 | 77 |
78 } // devtools | 78 } // devtools |
79 } // $package | 79 } // $package |
80 """) | 80 """) |
81 | 81 |
82 def Capitalize(s): | 82 def Capitalize(s): |
83 return s[:1].capitalize() + s[1:] | 83 return s[:1].capitalize() + s[1:] |
84 | 84 |
| 85 def ToIdentifier(s): |
| 86 return "".join([Capitalize(part) for part in s.split("-")]) |
| 87 |
85 references = [] | 88 references = [] |
86 | 89 |
87 def CreateNamespace(domain_name, data, keys, prefixes, name = None): | 90 def CreateNamespace(domain_name, data, keys, prefixes, name = None): |
88 result = {} | 91 result = {} |
89 if name: | 92 if name: |
90 result["kName"] = name | 93 result["kName"] = name |
91 for i, key in enumerate(keys): | 94 for i, key in enumerate(keys): |
92 if key in data: | 95 if key in data: |
93 for parameter in data[key]: | 96 for parameter in data[key]: |
94 parameter_name = parameter["name"]; | 97 parameter_name = parameter["name"]; |
95 result[prefixes[i] + Capitalize(parameter_name)] = parameter_name | 98 result[prefixes[i] + Capitalize(parameter_name)] = parameter_name |
96 if "enum" in parameter: | 99 if "enum" in parameter: |
97 enum_name = Capitalize(parameter_name) | 100 enum_name = Capitalize(parameter_name) |
98 result[enum_name] = {} | 101 result[enum_name] = {} |
99 for enum in parameter["enum"]: | 102 for enum in parameter["enum"]: |
100 result[enum_name]["kEnum" + Capitalize(enum)] = enum | 103 result[enum_name]["kEnum" + ToIdentifier(enum)] = enum |
101 reference = "" | 104 reference = "" |
102 if "$ref" in parameter: | 105 if "$ref" in parameter: |
103 reference = parameter["$ref"] | 106 reference = parameter["$ref"] |
104 if "items" in parameter and "$ref" in parameter["items"]: | 107 if "items" in parameter and "$ref" in parameter["items"]: |
105 reference = parameter["items"]["$ref"] | 108 reference = parameter["items"]["$ref"] |
106 if reference: | 109 if reference: |
107 if not "." in reference: | 110 if not "." in reference: |
108 reference = domain_name + "." + reference | 111 reference = domain_name + "." + reference |
109 references.append(reference) | 112 references.append(reference) |
110 return result | 113 return result |
111 | 114 |
112 def IsHandledInBrowser(item): | |
113 return "handlers" in item and "browser" in item["handlers"] | |
114 | |
115 def FormatContents(tree, indent, format_string): | 115 def FormatContents(tree, indent, format_string): |
116 outer = dict((key, value) for key, value in tree.iteritems() | 116 outer = dict((key, value) for key, value in tree.iteritems() |
117 if not isinstance(value, dict)) | 117 if not isinstance(value, dict)) |
118 inner = dict((key, value) for key, value in tree.iteritems() | 118 inner = dict((key, value) for key, value in tree.iteritems() |
119 if isinstance(value, dict)) | 119 if isinstance(value, dict)) |
120 body = "" | 120 body = "" |
121 body += "".join(indent + format_string.format(key, value) | 121 body += "".join(indent + format_string.format(key, value) |
122 for (key, value) in sorted(outer.items())) | 122 for (key, value) in sorted(outer.items())) |
123 body += "".join(FormatNamespace(key, value, indent, format_string) | 123 body += "".join(FormatNamespace(key, value, indent, format_string) |
124 for (key, value) in sorted(inner.items())) | 124 for (key, value) in sorted(inner.items())) |
(...skipping 30 matching lines...) Expand all Loading... |
155 | 155 |
156 domains = blink_protocol["domains"] | 156 domains = blink_protocol["domains"] |
157 | 157 |
158 namespace_tree = {} | 158 namespace_tree = {} |
159 | 159 |
160 for domain in domains: | 160 for domain in domains: |
161 domain_value = {} | 161 domain_value = {} |
162 domain_namespace_name = Capitalize(domain["domain"]) | 162 domain_namespace_name = Capitalize(domain["domain"]) |
163 if "commands" in domain: | 163 if "commands" in domain: |
164 for command in domain["commands"]: | 164 for command in domain["commands"]: |
165 if (IsHandledInBrowser(command)): | 165 domain_value[command["name"]] = CreateNamespace(domain["domain"], |
166 domain_value[command["name"]] = CreateNamespace(domain["domain"], | 166 command, ["parameters", "returns"], ["kParam", "kResponse"], |
167 command, ["parameters", "returns"], ["kParam", "kResponse"], | 167 domain_namespace_name + "." + command["name"]) |
168 domain_namespace_name + "." + command["name"]) | |
169 | 168 |
170 if "events" in domain: | 169 if "events" in domain: |
171 for event in domain["events"]: | 170 for event in domain["events"]: |
172 if IsHandledInBrowser(event): | 171 domain_value[event["name"]] = CreateNamespace(domain["domain"], |
173 domain_value[event["name"]] = CreateNamespace(domain["domain"], | 172 event, ["parameters"], ["kParam"], |
174 event, ["parameters"], ["kParam"], | 173 domain_namespace_name + "." + event["name"]) |
175 domain_namespace_name + "." + event["name"]) | |
176 if domain_value: | 174 if domain_value: |
177 namespace_tree[domain_namespace_name] = domain_value | 175 namespace_tree[domain_namespace_name] = domain_value |
178 | 176 |
179 while (references): | 177 while (references): |
180 reference = references.pop(); | 178 reference = references.pop(); |
181 path = reference.split("."); | 179 path = reference.split("."); |
182 parent_namespace = namespace_tree; | 180 parent_namespace = namespace_tree; |
183 for path_segment in path[0:-1]: | 181 for path_segment in path[0:-1]: |
184 if path_segment not in parent_namespace: | 182 if path_segment not in parent_namespace: |
185 parent_namespace[path_segment] = {} | 183 parent_namespace[path_segment] = {} |
186 parent_namespace = parent_namespace[path_segment] | 184 parent_namespace = parent_namespace[path_segment] |
187 if (path[-1] not in parent_namespace): | 185 if (path[-1] not in parent_namespace): |
188 try: | 186 try: |
189 domain = [d for d in domains if d["domain"] == path[0]][0] | 187 domain = [d for d in domains if d["domain"] == path[0]][0] |
190 ref_type = [t for t in domain["types"] if t["id"] == path[1]][0] | 188 ref_type = [t for t in domain["types"] if t["id"] == path[1]][0] |
191 parent_namespace[ref_type["id"]] = CreateNamespace(path[0], | 189 parent_namespace[ref_type["id"]] = CreateNamespace(path[0], |
192 ref_type, ["properties"], ["kParam"]) | 190 ref_type, ["properties"], ["kParam"]) |
193 except IndexError: | 191 except IndexError: |
194 sys.stderr.write("Failed to resolve type [{0}].\n".format(reference)) | 192 sys.stderr.write("Failed to resolve type [{0}].\n".format(reference)) |
195 sys.exit(1) | 193 sys.exit(1) |
196 | 194 |
197 for (namespace_name, namespace) in namespace_tree.items(): | 195 for (namespace_name, namespace) in namespace_tree.items(): |
198 namespace["kName"] = namespace_name | 196 namespace["kName"] = namespace_name |
199 | 197 |
200 with open(output_cc_path, "w") as f: | 198 with open(output_cc_path, "w") as f: |
201 CreateBody(namespace_tree, blink_version, f) | 199 CreateBody(namespace_tree, blink_version, f) |
202 | 200 |
203 with open(output_h_path, "w") as f: | 201 with open(output_h_path, "w") as f: |
204 CreateHeader(namespace_tree, f) | 202 CreateHeader(namespace_tree, f) |
OLD | NEW |