Add support for references in different paths in apis

extensions/generated_extensions_api.gni

 # 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.
 
 # Defines a static library corresponding to the output of schema compiler tools
 # over a set of extensions API schemas (IDL or JSON format.) The library target
 # has implicit hard dependencies on all schema files listed by the invoker and
 # is itself a hard dependency.
 #
 # Invocations of this template may use the following variables:
 #
 # sources [required] A list of schema files to be compiled.
 #
 # root_namespace [required]
 #     A Python string substituion pattern used to generate the C++
 #     namespace for each API. Use %(namespace)s to replace with the API
 #     namespace, like "toplevel::%(namespace)s_api".
 #
+# schema_include_rules [optional]
+#     A list of paths to include when searching for referenced objects,
+#     with the namespace separated by a :.
+#     Example:
+#       [ '/foo/bar:Foo::Bar::%(namespace)s' ]
+#
 # schemas [optional, default = false]
 #   Boolean indicating if the schema files should be generated.
 #
 # bundle [optional, default = false]
 #   Boolean indicating if the schema bundle files should be generated.
 #
 # bundle_registration [optional, default = false]
 #   Boolean indicating if the API registration bundle files should be generated.
 #
 # impl_dir [required if bundle_registration = true, otherwise unused]
@@ skipping 18 matching lines @@
   assert(defined(invoker.sources),
          "\"sources\" must be defined for the $target_name template.")
   assert(defined(invoker.root_namespace),
          "\"root_namespace\" must be defined for the $target_name template.")
 
   schemas = defined(invoker.schemas) && invoker.schemas
   bundle = defined(invoker.bundle) && invoker.bundle
   bundle_registration = defined(invoker.bundle_registration) &&
       invoker.bundle_registration
 
+  schema_include_rules = ""
+  if (defined(invoker.schema_include_rules)) {
+    schema_include_rules = invoker.schema_include_rules
+  }
+
   # Keep a copy of the target_name here since it will be trampled
   # in nested targets.
   target_visibility = ":$target_name"
 
   generated_config_name = target_name + "_generated_config"
   config(generated_config_name) {
     include_dirs = [ target_gen_dir ]
     visibility = target_visibility
   }
 
@@ skipping 22 matching lines @@
       inputs = compiler_sources
       outputs = [
         "$target_gen_dir/{{source_name_part}}.cc",
         "$target_gen_dir/{{source_name_part}}.h",
       ]
       args = [
         "{{source}}",
         "--root=" + rebase_path("//", root_build_dir),
         "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
         "--namespace=$root_namespace",
-        "--generator=cpp" ]
+        "--generator=cpp",
+        "--include-rules=$schema_include_rules" ]
       visibility = target_visibility
     }
   }
 
   if (bundle) {
     uncompiled_sources = []
     if (defined(invoker.uncompiled_sources)) {
      uncompiled_sources = invoker.uncompiled_sources
     }
 
     bundle_generator_schema_name = target_name + "_bundle_generator_schema"
     action(bundle_generator_schema_name) {
       script = compiler_script
       inputs = compiler_sources + sources + uncompiled_sources
       outputs = [
         "$target_gen_dir/generated_schemas.cc",
         "$target_gen_dir/generated_schemas.h",
       ]
       args = [
         "--root=" + rebase_path("//", root_build_dir),
         "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
         "--namespace=$root_namespace",
         "--generator=cpp-bundle-schema",
-      ] +
-        rebase_path(sources, root_build_dir) +
-        rebase_path(uncompiled_sources, root_build_dir)
+        "--include-rules=$schema_include_rules" ]
+        + rebase_path(sources, root_build_dir)
+        + rebase_path(uncompiled_sources, root_build_dir)
     }
   }
 
   if (bundle_registration) {
     uncompiled_sources = []
     if (defined(invoker.uncompiled_sources)) {
      uncompiled_sources = invoker.uncompiled_sources
     }
 
     assert(defined(invoker.impl_dir),
            "\"impl_dir\" must be defined for the $target_name template.")
     impl_dir = invoker.impl_dir
 
     bundle_generator_registration_name = target_name +
         "_bundle_generator_registration"
     action(bundle_generator_registration_name) {
       script = compiler_script
       inputs = compiler_sources + sources + uncompiled_sources
       outputs = [
         "$root_gen_dir/$impl_dir/generated_api_registration.cc",
         "$root_gen_dir/$impl_dir/generated_api_registration.h",
       ]
       args = [
         "--root=" + rebase_path("//", root_build_dir),
         "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
         "--namespace=$root_namespace",
         "--generator=cpp-bundle-registration",
         "--impl-dir=" + rebase_path(impl_dir, "//"),
-      ] +
-        rebase_path(sources, root_build_dir) +
-        rebase_path(uncompiled_sources, root_build_dir)
+        "--include-rules=$schema_include_rules" ]
+        + rebase_path(sources, root_build_dir)
+        + rebase_path(uncompiled_sources, root_build_dir)
     }
   }
 
   source_set(target_name) {
     sources = []
     deps = []
     
     if (schemas) {
       sources += get_target_outputs(":$schema_generator_name")
       deps += [
@@ skipping 18 matching lines @@
     direct_dependent_configs = [ ":$generated_config_name" ]
 
     if (defined(invoker.visibility)) {
       visibility = invoker.visibility
     }
     if (defined(invoker.output_name)) {
       output_name = invoker.output_name
     }
   }
 }