Plugin support for protobuf compiler (protoc) targets.

build/protoc.gypi

 # 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.
 
 # This file is meant to be included into a target to provide a rule
 # to invoke protoc in a consistent manner. For Java-targets, see
 # protoc_java.gypi.
 #
 # To use this, create a gyp target with the following form:
 # {
@@ skipping 34 matching lines @@
 # A proto_out_dir of foo/bar produces
 #   <(SHARED_INTERMEDIATE_DIR)/protoc_out/foo/bar/{file1,file2}.pb.{cc,h}
 #   <(SHARED_INTERMEDIATE_DIR)/pyproto/foo/bar/{file1,file2}_pb2.py
 
 {
   'variables': {
     'protoc_wrapper': '<(DEPTH)/tools/protoc_wrapper/protoc_wrapper.py',
     'cc_dir': '<(SHARED_INTERMEDIATE_DIR)/protoc_out/<(proto_out_dir)',
     'py_dir': '<(PRODUCT_DIR)/pyproto/<(proto_out_dir)',
     'cc_generator_options%': '',
+    'generate_python%': 1,
+    'generate_cc%': 1,
+    # Custom plugin target name.
+    # If passed, generator_plugin_suffix (before .cc and .h) is also required.
+    'generator_plugin%': '',

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

Could you rename it to "cc_generator_plugin" to make it clear that it only
supports generating C++ output (as .cc and .h are hardcoded)? If someone needs
plugin support for other languages, I'll ask them to refactor this to be even
more general and support more languages, but C++ support only will be fine for
now.

+    'generator_plugin_options%': '',
     'cc_include%': '',
     'proto_in_dir%': '.',
     'conditions': [
       ['use_system_protobuf==0', {
         'protoc': '<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)protoc<(EXECUTABLE_SUFFIX)',
       }, { # use_system_protobuf==1
         'protoc': '<!(which protoc)',
       }],
     ],
   },
   'rules': [
     {
       'rule_name': 'genproto',
       'extension': 'proto',
       'inputs': [
         '<(protoc_wrapper)',
         '<(protoc)',
       ],
-      'outputs': [
-        '<(py_dir)/<(RULE_INPUT_ROOT)_pb2.py',
-        '<(cc_dir)/<(RULE_INPUT_ROOT).pb.cc',
-        '<(cc_dir)/<(RULE_INPUT_ROOT).pb.h',
-      ],
       'action': [
         'python',
         '<(protoc_wrapper)',
+        # If no cc_include specified --protobuf option will be ignored.
         '--include',
         '<(cc_include)',
         '--protobuf',
         '<(cc_dir)/<(RULE_INPUT_ROOT).pb.h',
         # Using the --arg val form (instead of --arg=val) allows gyp's msvs rule
         # generation to correct 'val' which is a path.
         '--proto-in-dir','<(proto_in_dir)',
         # Naively you'd use <(RULE_INPUT_PATH) here, but protoc requires
         # --proto_path is a strict prefix of the path given as an argument.
         '--proto-in-file','<(RULE_INPUT_ROOT)<(RULE_INPUT_EXT)',
         '--use-system-protobuf=<(use_system_protobuf)',
         '--',
         '<(protoc)',
-        '--cpp_out', '<(cc_generator_options)<(cc_dir)',
-        '--python_out', '<(py_dir)',
       ],
       'message': 'Generating C++ and Python code from <(RULE_INPUT_PATH)',
       'process_outputs_as_sources': 1,
+
+      'conditions': [
+        ['generate_python==1', {
+          'outputs': [
+            '<(py_dir)/<(RULE_INPUT_ROOT)_pb2.py',
+          ],
+          'action': [
+            '--python_out',
+            '<(py_dir)',
+          ],
+        }],
+        ['generate_cc==1', {
+          'outputs': [
+            '<(cc_dir)/<(RULE_INPUT_ROOT).pb.cc',
+            '<(cc_dir)/<(RULE_INPUT_ROOT).pb.h',
+          ],
+          'action': [
+            '--cpp_out',
+            '<(cc_generator_options)<(cc_dir)',
+          ],
+        }],
+        ['generator_plugin!=""', {
+          'outputs': [
+            '<(cc_dir)/<(RULE_INPUT_ROOT)<(generator_plugin_suffix).cc',
+            '<(cc_dir)/<(RULE_INPUT_ROOT)<(generator_plugin_suffix).h',
+          ],
+          'action': [
+            '--plugin',
+            'protoc-gen-plugin=<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)<(generator_plugin)<(EXECUTABLE_SUFFIX)',
+            '--plugin_out',
+            '<(generator_plugin_options)<(cc_dir)',
+          ],
+        }],
+      ],
     },
   ],
   'dependencies': [
     '<(DEPTH)/third_party/protobuf/protobuf.gyp:protoc#host',
-    '<(DEPTH)/third_party/protobuf/protobuf.gyp:protobuf_lite',
   ],
   'include_dirs': [
     '<(SHARED_INTERMEDIATE_DIR)/protoc_out',
     '<(DEPTH)',
   ],
   'direct_dependent_settings': {
     'include_dirs': [
       '<(SHARED_INTERMEDIATE_DIR)/protoc_out',
       '<(DEPTH)',
     ]
   },
-  'export_dependent_settings': [
-    # The generated headers reference headers within protobuf_lite,
-    # so dependencies must be able to find those headers too.
-    '<(DEPTH)/third_party/protobuf/protobuf.gyp: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.
+  'conditions': [
+    ['generate_cc==1', {
+      'hard_dependency': 1,
+      'dependencies': [
+        '<(DEPTH)/third_party/protobuf/protobuf.gyp:protobuf_lite',
+      ],
+      'export_dependent_settings': [
+        '<(DEPTH)/third_party/protobuf/protobuf.gyp:protobuf_lite',
+      ],
+    }],
   ],
-  # This target exports a hard dependency because it generates header
-  # files.
-  'hard_dependency': 1,
 }