Mojo code generator: makes the filters member methods of generator if necessary.

So that we don't need to use global variables.

BUG=718614

Review-Url: https://codereview.chromium.org/2864543002
Cr-Commit-Position: refs/heads/master@{#469530}

mojo/public/tools/bindings/generators/mojom_java_generator.py

@@ -403,7 +403,16 @@ def TempDir():
     shutil.rmtree(dirname)
 
 class Generator(generator.Generator):
+  def _GetJinjaExports(self):
+    return {
+      'package': GetPackage(self.module),
+    }
+
+  @staticmethod
+  def GetTemplatePrefix():
+    return "java_templates"
 
+  def GetFilters(self):
     java_filters = {
       'array_expected_length': GetArrayExpectedLength,
       'array': GetArrayKind,
@@ -434,83 +443,71 @@ class Generator(generator.Generator):
       'new_array': NewArray,
       'ucc': lambda x: UpperCamelCase(x.name),
     }
+    return java_filters
 
-  def GetJinjaExports(self):
-    return {
-      'package': GetPackage(self.module),
-    }
-
-  @staticmethod
-  def GetTemplatePrefix():
-    return "java_templates"
-
-  @classmethod
-  def GetFilters(cls):
-    return cls.java_filters
-
-  def GetJinjaExportsForInterface(self, interface):
-    exports = self.GetJinjaExports()
+  def _GetJinjaExportsForInterface(self, interface):
+    exports = self._GetJinjaExports()
     exports.update({'interface': interface})
     return exports
 
   @UseJinja('enum.java.tmpl')
-  def GenerateEnumSource(self, enum):
-    exports = self.GetJinjaExports()
+  def _GenerateEnumSource(self, enum):
+    exports = self._GetJinjaExports()
     exports.update({'enum': enum})
     return exports
 
   @UseJinja('struct.java.tmpl')
-  def GenerateStructSource(self, struct):
-    exports = self.GetJinjaExports()
+  def _GenerateStructSource(self, struct):
+    exports = self._GetJinjaExports()
     exports.update({'struct': struct})
     return exports
 
   @UseJinja('union.java.tmpl')
-  def GenerateUnionSource(self, union):
-    exports = self.GetJinjaExports()
+  def _GenerateUnionSource(self, union):
+    exports = self._GetJinjaExports()
     exports.update({'union': union})
     return exports
 
   @UseJinja('interface.java.tmpl')
-  def GenerateInterfaceSource(self, interface):
-    return self.GetJinjaExportsForInterface(interface)
+  def _GenerateInterfaceSource(self, interface):
+    return self._GetJinjaExportsForInterface(interface)
 
   @UseJinja('interface_internal.java.tmpl')
-  def GenerateInterfaceInternalSource(self, interface):
-    return self.GetJinjaExportsForInterface(interface)
+  def _GenerateInterfaceInternalSource(self, interface):
+    return self._GetJinjaExportsForInterface(interface)
 
   @UseJinja('constants.java.tmpl')
-  def GenerateConstantsSource(self, module):
-    exports = self.GetJinjaExports()
+  def _GenerateConstantsSource(self, module):
+    exports = self._GetJinjaExports()
     exports.update({'main_entity': GetConstantsMainEntityName(module),
                     'constants': module.constants})
     return exports
 
-  def DoGenerateFiles(self):
+  def _DoGenerateFiles(self):
     fileutil.EnsureDirectoryExists(self.output_dir)
 
     # Keep this above the others as .GetStructs() changes the state of the
     # module, annotating structs with required information.
     for struct in self.GetStructs():
-      self.Write(self.GenerateStructSource(struct),
+      self.Write(self._GenerateStructSource(struct),
                  '%s.java' % GetNameForElement(struct))
 
     for union in self.module.unions:
-      self.Write(self.GenerateUnionSource(union),
+      self.Write(self._GenerateUnionSource(union),
                  '%s.java' % GetNameForElement(union))
 
     for enum in self.module.enums:
-      self.Write(self.GenerateEnumSource(enum),
+      self.Write(self._GenerateEnumSource(enum),
                  '%s.java' % GetNameForElement(enum))
 
     for interface in self.GetInterfaces():
-      self.Write(self.GenerateInterfaceSource(interface),
+      self.Write(self._GenerateInterfaceSource(interface),
                  '%s.java' % GetNameForElement(interface))
-      self.Write(self.GenerateInterfaceInternalSource(interface),
+      self.Write(self._GenerateInterfaceInternalSource(interface),
                  '%s_Internal.java' % GetNameForElement(interface))
 
     if self.module.constants:
-      self.Write(self.GenerateConstantsSource(self.module),
+      self.Write(self._GenerateConstantsSource(self.module),
                  '%s.java' % GetConstantsMainEntityName(self.module))
 
   def GenerateFiles(self, unparsed_args):
@@ -529,13 +526,13 @@ class Generator(generator.Generator):
     zip_filename = os.path.join(self.output_dir, basename)
     with TempDir() as temp_java_root:
       self.output_dir = os.path.join(temp_java_root, package_path)
-      self.DoGenerateFiles();
+      self._DoGenerateFiles();
       build_utils.ZipDir(zip_filename, temp_java_root)
 
     if args.java_output_directory:
       # If requested, generate the java files directly into indicated directory.
       self.output_dir = os.path.join(args.java_output_directory, package_path)
-      self.DoGenerateFiles();
+      self._DoGenerateFiles();
 
   def GetJinjaParameters(self):
     return {

mojo/public/tools/bindings/generators/mojom_js_generator.py

@@ -342,7 +342,25 @@ def GetRelativePath(module, base_module):
 
 
 class Generator(generator.Generator):
+  def _GetParameters(self):
+    return {
+      "namespace": self.module.namespace,
+      "imports": self._GetImports(),
+      "kinds": self.module.kinds,
+      "enums": self.module.enums,
+      "module": self.module,
+      "structs": self.GetStructs() + self.GetStructsFromMethods(),
+      "unions": self.GetUnions(),
+      "use_new_js_bindings": self.use_new_js_bindings,
+      "interfaces": self.GetInterfaces(),
+      "imported_interfaces": self._GetImportedInterfaces(),
+    }
 
+  @staticmethod
+  def GetTemplatePrefix():
+    return "js_templates"
+
+  def GetFilters(self):
     js_filters = {
       "decode_snippet": JavaScriptDecodeSnippet,
       "default_value": JavaScriptDefaultValue,
@@ -353,7 +371,8 @@ class Generator(generator.Generator):
       "is_any_handle_or_interface_field": IsAnyHandleOrInterfaceField,
       "is_array_pointer_field": IsArrayPointerField,
       "is_associated_interface_field": IsAssociatedInterfaceField,
-    "is_associated_interface_request_field": IsAssociatedInterfaceRequestField,
+      "is_associated_interface_request_field":
+          IsAssociatedInterfaceRequestField,
       "is_bool_field": IsBoolField,
       "is_enum_field": IsEnumField,
       "is_handle_field": IsHandleField,
@@ -378,41 +397,20 @@ class Generator(generator.Generator):
       "validate_struct_params": JavaScriptValidateStructParams,
       "validate_union_params": JavaScriptValidateUnionParams,
     }
-
-  def GetParameters(self):
-    return {
-      "namespace": self.module.namespace,
-      "imports": self.GetImports(),
-      "kinds": self.module.kinds,
-      "enums": self.module.enums,
-      "module": self.module,
-      "structs": self.GetStructs() + self.GetStructsFromMethods(),
-      "unions": self.GetUnions(),
-      "use_new_js_bindings": self.use_new_js_bindings,
-      "interfaces": self.GetInterfaces(),
-      "imported_interfaces": self.GetImportedInterfaces(),
-    }
-
-  @staticmethod
-  def GetTemplatePrefix():
-    return "js_templates"
-
-  @classmethod
-  def GetFilters(cls):
-    return cls.js_filters
+    return js_filters
 
   @UseJinja("module.amd.tmpl")
-  def GenerateAMDModule(self):
-    return self.GetParameters()
+  def _GenerateAMDModule(self):
+    return self._GetParameters()
 
   def GenerateFiles(self, args):
     if self.variant:
       raise Exception("Variants not supported in JavaScript bindings.")
 
-    self.Write(self.GenerateAMDModule(),
+    self.Write(self._GenerateAMDModule(),
         self.MatchMojomFilePath("%s.js" % self.module.name))
 
-  def GetImports(self):
+  def _GetImports(self):
     used_names = set()
     for each_import in self.module.imports:
       simple_name = each_import["module_name"].split(".")[0]
@@ -430,7 +428,7 @@ class Generator(generator.Generator):
       counter += 1
     return self.module.imports
 
-  def GetImportedInterfaces(self):
+  def _GetImportedInterfaces(self):
     interface_to_import = {};
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces: