IDL generated extensions code only generate foo_api.h when required

tools/json_schema_compiler/schema_bundle_generator.py

 # Copyright (c) 2012 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 code
 import cpp_util
 from model import Platforms
 from schema_util import CapitalizeFirstLetter
 from schema_util import JsFunctionNameToClassName
 
 import json
 import os
 import re
 
 # TODO(miket/asargent) - parameterize this.
 SOURCE_BASE_PATH = 'chrome/common/extensions/api'
 
 class SchemaBundleGenerator(object):
   """This class contains methods to generate code based on multiple schemas.
   """
 
-  def __init__(self, model, api_defs, cpp_type_generator):
+  def __init__(self, root, model, api_defs, cpp_type_generator):
+    self._root = root;
     self._model = model
     self._api_defs = api_defs
     self._cpp_type_generator = cpp_type_generator
 
   def GenerateHeader(self, file_base, body_code):
     """Generates a code.Code object for a header file
 
     Parameters:
     - |file_base| - the base of the filename, e.g. 'foo' (for 'foo.h')
     - |body_code| - the code to put in between the multiple inclusion guards"""
@@ skipping 28 matching lines @@
 
   def GenerateAPIHeader(self):
     """Generates the header for API registration / declaration"""
     c = code.Code()
 
     c.Append('#include <string>')
     c.Append()
     c.Append('#include "base/basictypes.h"')
 
     for namespace in self._model.namespaces.values():
-      ifdefs = self._GetPlatformIfdefs(namespace)
-      if ifdefs is not None:
-        c.Append("#if %s" % ifdefs, indent_level=0)
-
       namespace_name = namespace.unix_name.replace("experimental_", "")
       implementation_header = namespace.compiler_options.get(
           "implemented_in",
           "chrome/browser/extensions/api/%s/%s_api.h" % (namespace_name,
                                                          namespace_name))
+      if not os.path.exists(
+          os.path.join(self._root, os.path.normpath(implementation_header))):
+        if "implemented_in" in namespace.compiler_options:
+          raise ValueError('Header file for namespace "%s" specified in '
+                          'compiler_options not found: %s' %
+                          (namespace.unix_name, implementation_header))
+        continue
+      ifdefs = self._GetPlatformIfdefs(namespace)
+      if ifdefs is not None:
+        c.Append("#if %s" % ifdefs, indent_level=0)
+
       c.Append('#include "%s"' % implementation_header)
 
       if ifdefs is not None:
         c.Append("#endif  // %s" % ifdefs, indent_level=0)
 
     c.Append()
     c.Append("class ExtensionFunctionRegistry;")
     c.Append()
 
     c.Concat(self._cpp_type_generator.GetRootNamespaceStart())
@@ skipping 91 matching lines @@
       for index, line in enumerate(lines):
         line = '    "%s"' % line
         if index == len(lines) - 1:
           line += ';'
         c.Append(line)
     c.Eblock('}')
     c.Append()
     c.Concat(self._cpp_type_generator.GetRootNamespaceEnd())
     c.Append()
     return c