Add option cc_wrapper to GN

build/toolchain/gcc_toolchain.gni

 # Copyright (c) 2013 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.
 
 import("//build/config/nacl/config.gni")
 import("//build/config/sanitizers/sanitizers.gni")
-import("//build/toolchain/ccache.gni")
+import("//build/toolchain/cc_wrapper.gni")
 import("//build/toolchain/goma.gni")
 import("//build/toolchain/toolchain.gni")
 
 # This value will be inherited in the toolchain below.
 if (is_cfi) {
   concurrent_links =
       exec_script("get_concurrent_links.py", [ "--lto" ], "value")
 } else {
   concurrent_links = exec_script("get_concurrent_links.py", [], "value")
 }
@@ skipping 55 matching lines @@
 #      When set to true, is_asan, is_msan, etc.will all be set to false. Often
 #      secondary toolchains do not want to run with sanitizers.
 #  - is_clang
 #      Whether to use clang instead of gcc.
 #  - is_component_build
 #      Whether to forcibly enable or disable component builds for this
 #      toolchain; if not specified, the toolchain will inherit the
 #      default setting.
 #  - is_nacl_glibc
 #      Whether NaCl code is built using Glibc instead of Newlib.
-#  - use_ccache
-#      Override the global use_ccache setting, useful to opt-out of ccache in
-#      a particular toolchain by setting use_ccache = false in it.
+#  - cc_wrapper
+#      Override the global cc_wrapper setting. e.g. "ccache" or "icecc".
+#      useful to opt-out of cc_wrapper in a particular toolchain by setting
+#      cc_wrapper = "" in it.
 #  - use_goma
 #      Override the global use_goma setting, useful to opt-out of goma in a
 #      particular toolchain by setting use_gome = false in it.
 #  - use_gold
 #      Override the global use_gold setting, useful if the particular
 #      toolchain has a custom link step that is not actually using Gold.
 template("gcc_toolchain") {
   toolchain(target_name) {
     assert(defined(invoker.cc), "gcc_toolchain() must specify a \"cc\" value")
     assert(defined(invoker.cxx), "gcc_toolchain() must specify a \"cxx\" value")
     assert(defined(invoker.ar), "gcc_toolchain() must specify a \"ar\" value")
     assert(defined(invoker.ld), "gcc_toolchain() must specify a \"ld\" value")
     assert(defined(invoker.toolchain_cpu),
            "gcc_toolchain() must specify a \"toolchain_cpu\"")
     assert(defined(invoker.toolchain_os),
            "gcc_toolchain() must specify a \"toolchain_os\"")
 
-    if (defined(invoker.use_ccache)) {
-      use_ccache = invoker.use_ccache
+    if (defined(invoker.cc_wrapper)) {
+      cc_wrapper = invoker.cc_wrapper
     }
     if (defined(invoker.use_goma)) {
       use_goma = invoker.use_goma
     }
     if (use_goma) {
-      assert(!use_ccache, "Goma and ccache can't be used together.")
+      assert(cc_wrapper == "", "Goma and cc_wrapper can't be used together.")
       compiler_prefix = "$goma_dir/gomacc "
-    } else if (use_ccache) {
-      compiler_prefix = "ccache "
+    } else if (cc_wrapper != "") {
+      compiler_prefix = cc_wrapper + " "
     } else {
       compiler_prefix = ""
     }
 
     # This define changes when the toolchain changes, forcing a rebuild.
     # Nothing should ever use this define.
     if (defined(invoker.rebuild_define)) {
       rebuild_string = "-D" + invoker.rebuild_define + " "
     } else {
       rebuild_string = ""
@@ skipping 294 matching lines @@
         is_tsan = false
         is_ubsan = false
         is_ubsan_vptr = false
       }
     }
 
     forward_variables_from(invoker, [ "deps" ])
   }
 }
 
-declare_args() {
-  clang_dir = "//third_party/llvm-build/Release+Asserts"
-}
-
 # This is a shorthand for gcc_toolchain instances based on the
 # Chromium-built version of Clang.  Only the toolchain_cpu and
 # toolchain_os variables need to be specified by the invoker, and
 # optionally toolprefix if it's a cross-compile case.  Note that for
 # a cross-compile case this toolchain requires a config to pass the
 # appropriate -target option, or else it will actually just be doing
 # a native compile.  The invoker can optionally override use_gold too.
 template("clang_toolchain") {
   assert(defined(invoker.toolchain_cpu),
          "clang_toolchain() must specify a \"toolchain_cpu\"")
   assert(defined(invoker.toolchain_os),
          "clang_toolchain() must specify a \"toolchain_os\"")
   if (defined(invoker.toolprefix)) {
     toolprefix = invoker.toolprefix
   } else {
     toolprefix = ""
   }
 
   gcc_toolchain(target_name) {
-    prefix = rebase_path(clang_dir + "/bin", root_build_dir)
+    prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
+                         root_build_dir)
     cc = "$prefix/clang"
     cxx = "$prefix/clang++"
     ld = cxx
     is_clang = true
 
     readelf = "${toolprefix}readelf"
     ar = "${toolprefix}ar"
     nm = "${toolprefix}nm"
 
     forward_variables_from(invoker,
                            [
                              "toolchain_cpu",
                              "toolchain_os",
                              "use_gold",
                            ])
   }
 }