Plugin support for protobuf compiler (protoc) targets.

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_out_dir (optional)
 #       Specifies the path suffix that output files are generated under. This
 #       path will be appended to the root_gen_dir.
 #
 #       Targets that depend on the proto target will be able to include the
 #       resulting proto headers with an include like:
 #         #include "dir/for/my_proto_lib/foo.pb.h"
 #       If undefined, this defaults to matching the input directory for each
 #       .proto file (you should almost always use the default mode).
 #
+#   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:
 #       'dllexport_decl=FOO_EXPORT:' (note trailing colon).
 #
 #       It is likely you also need to #include a file for the above EXPORT
 #       macro to work. See cc_include.
 #
+#   generator_plugin (optional)

[xyzzyz, 2016/06/21 20:29:44]

Same as in gypi (cc_generator_plugin and same for other variables)

+#       Custom plugin target name.
+#
+#   generator_plugin_suffix (required if generator_plugin set)
+#       Suffix (before extension) for generated .cc and .h files.
+#
+#   generator_plugin_options (optional)
+#       Extra flags passed to the plugin. See cc_generator_options.
+#
 #   cc_include (optional)
 #       String listing an extra include that should be passed.
 #       Example: cc_include = "foo/bar.h"
 #
 #   deps (optional)
 #       Additional dependencies.
 #
 # Parameters for compiling the generated code:
 #
 #   defines (optional)
@@ skipping 26 matching lines @@
     visibility = [ ":$source_set_name" ]
 
     script = "//tools/protoc_wrapper/protoc_wrapper.py"
 
     sources = invoker.sources
 
     # Compute the output directory, both relative to the source root (for
     # declaring "outputs") and relative to the build dir (for passing to the
     # script).
     if (defined(invoker.proto_out_dir)) {
-      # Put the results in the specified dir in the gen tree.
-      out_dir = "$root_gen_dir/" + invoker.proto_out_dir
-      rel_out_dir = rebase_path(out_dir, root_build_dir)
-      py_out_dir = "$root_out_dir/pyproto/" + invoker.proto_out_dir
+      proto_out_dir = invoker.proto_out_dir
     } else {
-      # Use the gen directory corresponding to the source file for C++ sources.
-      # This expansion will be done differently in the outputs and the args, so
-      # we don't need to worry about rebasing as above. Always put Python
-      # sources in "pyproto".
-      out_dir = "{{source_gen_dir}}"
-      rel_out_dir = "{{source_gen_dir}}"
-      py_out_dir = "$root_out_dir/pyproto/{{source_root_relative_dir}}"
+      proto_out_dir = "{{source_root_relative_dir}}"
     }
-    rel_py_out_dir = rebase_path(py_out_dir, root_build_dir)
+    out_dir = "$root_gen_dir/" + proto_out_dir
+    rel_out_dir = rebase_path(out_dir, root_build_dir)
 
-    outputs = [
-      "$py_out_dir/{{source_name_part}}_pb2.py",
-      "$out_dir/{{source_name_part}}.pb.cc",
-      "$out_dir/{{source_name_part}}.pb.h",
-    ]
+    outputs = []
 
     args = []
     if (defined(invoker.cc_include)) {
       args += [
         "--include",
         invoker.cc_include,
+        "--protobuf",
+        "$rel_out_dir/{{source_name_part}}.pb.h",
       ]
     }
 
     args += [
-      "--protobuf",
-      "$rel_out_dir/{{source_name_part}}.pb.h",
       "--proto-in-dir",
       "{{source_dir}}",
       "--proto-in-file",
       "{{source_file_part}}",
 
       # TODO(brettw) support system protobuf compiler.
       "--use-system-protobuf=0",
     ]
 
     protoc_label = "//third_party/protobuf:protoc($host_toolchain)"
     args += [
       "--",
 
       # Prepend with "./" so this will never pick up the system one (normally
       # when not cross-compiling, protoc's output directory will be the same
       # as the build dir, so the relative location will be empty).
       "./" +
           rebase_path(get_label_info(protoc_label, "root_out_dir") + "/protoc",
                       root_build_dir),
     ]
 
-    # If passed cc_generator_options should end in a colon, which will separate
-    # it from the directory when we concatenate them. The proto compiler
-    # understands this syntax.
-    if (defined(invoker.cc_generator_options)) {
-      cc_generator_options = invoker.cc_generator_options
-    } else {
-      cc_generator_options = ""
+    if (!defined(invoker.generate_python) || invoker.generate_python) {
+      py_out_dir = "$root_out_dir/pyproto/" + proto_out_dir
+      rel_py_out_dir = rebase_path(py_out_dir, root_build_dir)
+
+      outputs += [ "$py_out_dir/{{source_name_part}}_pb2.py" ]
+      args += [
+        "--python_out",
+        rel_py_out_dir,
+      ]
     }
-    args += [
-      # cc_generator_options is supposed to end in a colon if it's nonempty.
-      "--cpp_out",
-      "$cc_generator_options$rel_out_dir",
-      "--python_out",
-      rel_py_out_dir,
-    ]
+
+    if (!defined(invoker.generate_cc) || invoker.generate_cc) {
+      if (defined(invoker.cc_generator_options)) {
+        cc_generator_options = invoker.cc_generator_options
+      } else {
+        cc_generator_options = ""
+      }
+      outputs += [
+        "$out_dir/{{source_name_part}}.pb.cc",
+        "$out_dir/{{source_name_part}}.pb.h",
+      ]
+      args += [
+        "--cpp_out",
+        "$cc_generator_options$rel_out_dir",  # Separated by colon.

[xyzzyz, 2016/06/21 20:29:44]

Could you keep the original comment about colon? It's more informative.

+      ]
+    }
+
+    if (defined(invoker.generator_plugin)) {
+      generator_plugin = invoker.generator_plugin
+      generator_plugin_suffix = invoker.generator_plugin_suffix
+      if (defined(invoker.generator_plugin_options)) {
+        generator_plugin_options = invoker.generator_plugin_options
+      } else {
+        generator_plugin_options = ""
+      }
+      outputs += [
+        "$out_dir/{{source_name_part}}$generator_plugin_suffix.cc",
+        "$out_dir/{{source_name_part}}$generator_plugin_suffix.h",
+      ]
+      args += [
+        "--plugin",
+        "protoc-gen-plugin=./$generator_plugin",
+        "--plugin_out",
+        "$generator_plugin_options$rel_out_dir",  # Separated by colon.
+      ]
+    }
 
     deps = [
       protoc_label,
     ]
 
-    # The deps may have steps that have to run before runnign protobuf.
+    # The deps may have steps that have to run before running protobuf.
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
   }
 
   source_set(target_name) {
     forward_variables_from(invoker,
                            [
                              "visibility",
                              "defines",
                            ])
 
     sources = get_target_outputs(":$action_name")
 
     if (defined(invoker.extra_configs)) {
       configs += invoker.extra_configs
     }
 
     public_configs = [ "//third_party/protobuf:using_proto" ]
 
-    public_deps = [
-      # The generated headers reference headers within protobuf_lite, so
-      # dependencies must be able to find those headers too.
-      "//third_party/protobuf:protobuf_lite",
-    ]
+    # If using built-in cc generator the resulting headers reference headers
+    # within protobuf_lite, hence dependencies require those headers too.
+    # In case of generator plugin such issues should be resolved by invoker.
+    if (!defined(invoker.generate_cc) || invoker.generate_cc) {
+      public_deps = [
+        "//third_party/protobuf:protobuf_lite",
+      ]
+    }
     deps = [
       ":$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
     }
   }
 }