Allow proto-path in the proto_library target

third_party/protobuf/proto_library.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.
 
 # Compile a protocol buffer.
 #
 # Protobuf parameters:
 #
 #   proto_in_dir (optional)
 #       Specifies the path relative to the current BUILD.gn file where
 #       proto files are located and the directory structure of
 #       this proto library starts.
 #
 #       This option can be calculated automatically but it will raise an
 #       assertion error if any nested directories are found.
 #
 #   proto_out_dir (optional)
 #       Specifies the path suffix that output files are generated under.
 #       This path will be appended to |root_gen_dir|, but for python stubs
 #       it will be appended to |root_build_dir|/pyproto.
 #
+#   proto_path (optional)
+#       List of additional directories to find imported protos.
+#
 #   generate_python (optional, default true)
 #       Generate Python protobuf stubs.
 #
 #   generate_cc (optional, default true)
 #       Generate C++ protobuf stubs.
 #
 #   cc_generator_options (optional)
 #       List of extra flags passed to the protocol compiler.  If you need to
 #       add an EXPORT macro to a protobuf's C++ header, set the
 #       'cc_generator_options' variable with the value:
@@ skipping 197 matching lines @@
     protoc_out_dir = get_label_info(protoc_label, "root_out_dir")
     args += [
       # Wrapper should never pick a system protoc.
       # Path should be rebased because |root_build_dir| for current toolchain
       # may be different from |root_out_dir| of protoc built on host toolchain.
       "--protoc",
       "./" + rebase_path(protoc_out_dir, root_build_dir) + "/protoc",
       "--proto-in-dir",
       rebase_path(proto_in_dir, root_build_dir),
     ]
+    if (defined(invoker.proto_path)) {
+      foreach(_proto_dir, invoker.proto_path) {
+        args += [
+          "--proto-path",
+          rebase_path(_proto_dir, root_build_dir),
+        ]
+      }
+    }
 
     if (generate_cc) {
       args += [
         "--cc-out-dir",
         rel_cc_out_dir,
       ]
       if (defined(invoker.cc_generator_options)) {
         args += [
           "--cc-options",
           invoker.cc_generator_options,
@@ skipping 38 matching lines @@
       deps += [ plugin_host_label ]
     }
     if (defined(invoker.deps)) {
       # The deps may have steps that have to run before running protoc.
       deps += invoker.deps
     }
   }
 
   # Option to disable building a library in component build.
   if (defined(invoker.component_build_force_source_set) &&
-      invoker.component_build_force_source_set &&
-      is_component_build) {
+      invoker.component_build_force_source_set && is_component_build) {
     link_target_type = "source_set"
   } else {
     link_target_type = "static_library"
   }
 
   # Generated files may include other generated headers. These includes always
   # use relative paths starting at |cc_out_dir|.
   # However there is no necessity to add an additional directory, if all protos
   # are located in the same directory which is in the search path by default.
   if (has_nested_dirs) {
@@ skipping 11 matching lines @@
                              "testonly",
                              "visibility",
                            ])
 
     sources = get_target_outputs(":$action_name")
 
     if (defined(invoker.extra_configs)) {
       configs += invoker.extra_configs
     }
 
-    public_configs = [ "//third_party/protobuf:using_proto" ]
+    if (!defined(invoker.public_configs)) {

[sdefresne, 2016/10/06 16:44:44]

The pattern we usually use is the following:

forward_variables_from(invoker,
                       [
                         "defines",
                         "public_configs",
                         "testonly",
                         "visibility",
                       ])

if (!defined(public_configs)) {
  public_configs = []
}
public_configs += [ "//third_party/protobuf:using_proto" ]

+      public_configs = []
+    } else {
+      public_configs = invoker.public_configs
+    }
+
+    public_configs += [ "//third_party/protobuf:using_proto" ]
 
     if (generate_cc || generate_with_plugin) {
       # Not necessary if all protos are located in the same directory.
       if (has_nested_dirs) {
         # It's not enough to set |include_dirs| for target since public imports
         # expose corresponding includes to header files as well.
         public_configs += [ ":$config_name" ]
       }
 
       # If using built-in cc generator, the resulting headers reference headers
@@ skipping 10 matching lines @@
       ":$action_name",
     ]
 
     # This will link any libraries in the deps (the use of invoker.deps in the
     # action won't link it).
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
   }
 }