Roll IDL to multivm@1329

core/scripts/name_macros.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 63 matching lines @@
         self._entries_by_conditional = {}
         self._unconditional_entries = []
         self._sort_entries_by_conditional()
         self._outputs = {(self.class_name + "Headers.h"): self.generate_headers_header,
                          (self.class_name + "Interfaces.h"): self.generate_interfaces_header,
                         }
 
     def _sort_entries_by_conditional(self):
         unconditional_names = set()
         for entry in self.in_file.name_dictionaries:
-            conditional = entry['conditional']
+            conditional = entry['Conditional']
             if not conditional:
                 name = self._class_name_for_entry(entry)
                 if name in unconditional_names:
                     continue
                 unconditional_names.add(name)
                 self._unconditional_entries.append(entry)
                 continue
         for entry in self.in_file.name_dictionaries:
             name = self._class_name_for_entry(entry)
             if name in unconditional_names:
                 continue
-            conditional = entry['conditional']
+            conditional = entry['Conditional']
             if not conditional in self._entries_by_conditional:
                 self._entries_by_conditional[conditional] = []
             self._entries_by_conditional[conditional].append(entry)
 
     def _class_name_for_entry(self, entry):
-        if entry['implementedAs']:
-            return entry['implementedAs']
+        if entry['ImplementedAs']:
+            return entry['ImplementedAs']
         return os.path.basename(entry['name'])
 
     def _headers_header_include_path(self, entry):
-        if entry['implementedAs']:
+        if entry['ImplementedAs']:
             path = os.path.dirname(entry['name'])
             if len(path):
                 path += '/'
-            path += entry['implementedAs']
+            path += entry['ImplementedAs']
         else:
             path = entry['name']
         return path + '.h'
 
     def _headers_header_includes(self, entries):
         includes = dict()
         for entry in entries:
             class_name = self._class_name_for_entry(entry)
             # Avoid duplicate includes.
             if class_name in includes:
                 continue
             include = '#include "%(path)s"\n#include "V8%(js_name)s.h"' % {
                 'path': self._headers_header_include_path(entry),
                 'js_name': os.path.basename(entry['name']),
             }
-            includes[class_name] = self.wrap_with_condition(include, entry['conditional'])
+            includes[class_name] = self.wrap_with_condition(include, entry['Conditional'])
         return includes.values()
 
     def generate_headers_header(self):
         return HEADER_TEMPLATE % {
             'license': license.license_for_generated_cpp(),
             'class_name': self.class_name,
             'includes': '\n'.join(self._headers_header_includes(self.in_file.name_dictionaries)),
         }
 
     def _declare_one_conditional_macro(self, conditional, entries):
@@ skipping 28 matching lines @@
 
     def generate_interfaces_header(self):
         return INTERFACES_HEADER_TEMPLATE % {
             'license': license.license_for_generated_cpp(),
             'class_name': self.class_name,
             'macro_style_name': _to_macro_style(self.class_name),
             'declare_conditional_macros': self._declare_conditional_macros(),
             'unconditional_macros': '\n'.join(sorted(set(map(self._unconditional_macro, self._unconditional_entries)))),
             'conditional_macros': '\n'.join(map(self._conditional_macros, self._entries_by_conditional.keys())),
         }