Adds new GN template go_binary

mojo/go/rules.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.
 
 declare_args() {
   # By default, there is no go build tool, because go builds are not supported.
   go_build_tool = ""
 }
 
 # Declare a go library.
@@ skipping 73 matching lines @@
              rebase_path(root_out_dir, root_build_dir),
              "-I" + rebase_path("//"),
              "-L" + rebase_path(target_out_dir) + " -l" + static_library_name +
                  " -lstdc++ -lpthread -lm -lglib-2.0 -lrt",
              "test",
              "-c",
            ] + rebase_path(invoker.sources, build_dir)
   }
 }
 
+template("go_application") {

[rogulenko, 2015/10/01 18:48:07]

My high level question is how are you going to use it?
If you just want to simulate a normal 'go build ...' command, then you don't
need half of the stuff here: you don't need the static_library, the copy target
and the cgo stuff. I'm not sure if you need android. Also it would be nice to
get rid of the build_dir trick since the current version of the go tool supports
the -o flag.

[rudominer, 2015/10/02 16:36:00]

I plan to use this to build the new version of the Mojom compiler
which is written in Go. This application needs to link against
the Mojo Go bindings because it will serialize the compiler's
intermediate representation to a Mojo message. This means that
I do need to use cgo and depend on the target
//mojo/public/platform/native:system.
(As an aside it should be possible to
refactor the Go bindings so that the native code is not
necessary for doing serialization. But that is a different
project.)

Here is what my invocation looks like:

go_binary("mojom_parser") {
  sources = [
    "parser_main.go",
  ]
  inputs = [
    "generated/mojom_files/mojom_files.mojom.go",
    <some files elided from the list here>
    "parser/parsing.go",
  ]
  deps = [
    "//mojo/public/platform/native:system",
  ]
}


you don't need the static_library, the copy target
I got rid of Android support.

Also it would be nice to
The current version of the go compiler checked into Mojo's third-party does not
yet support the -o flag. I have added a TODO to update the go compiler and then
simplify the rules in this file. I will do that in a follow up CL.

+  assert(is_android || is_linux)
+  assert(defined(invoker.sources))
+  assert(defined(invoker.deps))
+  assert(defined(invoker.static_library_sources))
+  assert(go_build_tool != "")
+
+  static_library_name = target_name + "_static_library"
+  static_library(static_library_name) {
+    complete_static_lib = true
+    sources = invoker.static_library_sources
+    deps = invoker.deps
+  }
+
+  go_binary_name = target_name + "_go"
+  action(go_binary_name) {
+    deps = invoker.deps + [ ":${static_library_name}" ]
+    script = "//mojo/go/go.py"
+    inputs = invoker.sources
+    outputs = [
+      "${target_out_dir}/${target_name}",
+    ]
+
+    # Since go build does not permit specifying an output directory or output
+    # binary name, we create a temporary build directory, and the python
+    # script will later identify the output, copy it to the target location,
+    # and clean up the temporary build directory.
+    build_dir = "${target_out_dir}/${target_name}_build"
+    args = []
+    if (is_android) {
+      args += [ "--android" ]
+    }
+    args += [
+      "--",
+      "${go_build_tool}",
+      rebase_path(build_dir, root_build_dir),
+      rebase_path(target_out_dir, root_build_dir) + "/${target_name}",
+      rebase_path("//", root_build_dir),
+      rebase_path(root_out_dir, root_build_dir),
+      "-I" + rebase_path("//"),
+      "-L" + rebase_path(target_out_dir) + " -l" + static_library_name + "",
+      "build",
+    ]
+    args += rebase_path(invoker.sources, build_dir)
+  }
+
+  copy(target_name) {
+    deps = [
+      ":${go_binary_name}",
+    ]
+    sources = [
+      "${target_out_dir}/${go_binary_name}",
+    ]
+    outputs = [
+      "${root_out_dir}/${target_name}",
+    ]
+  }
+}
+
 template("go_mojo_application") {
   assert(is_android || is_linux)
   assert(defined(invoker.sources))
   assert(go_build_tool != "")
 
   static_library_name = target_name + "_static_library"
   static_library(static_library_name) {
     complete_static_lib = true
     deps = [
       "//mojo/public/platform/native:system",
@@ skipping 43 matching lines @@
       ":${go_library_name}",
     ]
     sources = [
       "${target_out_dir}/${go_library_name}",
     ]
     outputs = [
       "${root_out_dir}/${target_name}.mojo",
     ]
   }
 }