Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

build/config/compiler/BUILD.gn

 # 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/android/config.gni")
-if (current_cpu == "arm") {
+if (cpu_arch == "arm") {
   import("//build/config/arm.gni")
 }
-if (current_cpu == "mipsel" || current_cpu == "mips64el") {
+if (cpu_arch == "mipsel" || cpu_arch == "mips64el") {
   import("//build/config/mips.gni")
 }
 if (is_posix) {
   import("//build/config/gcc/gcc_version.gni")
 }
 
 import("//build/toolchain/ccache.gni")
 
 declare_args() {
   # Normally, Android builds are lightly optimized, even for debug builds, to
   # keep binary size down. Setting this flag to true disables such optimization
   android_full_debug = false
 
   # Whether to use the binary binutils checked into third_party/binutils.
   # These are not multi-arch so cannot be used except on x86 and x86-64 (the
   # only two architectures that are currently checked in). Turn this off when
   # you are using a custom toolchain and need to control -B in cflags.
-  linux_use_bundled_binutils = is_linux && current_cpu == "x64"
+  linux_use_bundled_binutils = is_linux && cpu_arch == "x64"
 
   # Compile in such a way as to enable profiling of the generated code. For
   # example, don't omit the frame pointer and leave in symbols.
   enable_profiling = false
 
   # Compile in such a way as to make it possible for the profiler to unwind full
   # stack frames. Setting this flag has a large effect on the performance of the
   # generated code than just setting profiling, but gives the profiler more
   # information to analyze.
   # Requires profiling to be set to true.
   enable_full_stack_frames_for_profiling = false
 
   # Use gold for linking on 64-bit Linux only (on 32-bit it runs out of
   # address space, and it doesn't support cross-compiling).
-  use_gold = is_linux && current_cpu == "x64"
+  use_gold = is_linux && cpu_arch == "x64"
 
   # use_debug_fission: whether to use split DWARF debug info
   # files. This can reduce link time significantly, but is incompatible
   # with some utilities such as icecc and ccache. Requires gold and
   # gcc >= 4.8 or clang.
   # http://gcc.gnu.org/wiki/DebugFission
   use_debug_fission =
       !is_win && use_gold && linux_use_bundled_binutils && !use_ccache
 }
 
@@ skipping 61 matching lines @@
     if (is_mac) {
       cflags += [ "-fstack-protector-all" ]
     } else if (is_linux) {
       cflags += [
         "-fstack-protector",
         "--param=ssp-buffer-size=4",
       ]
     }
 
     # Linker warnings.
-    if (!(is_chromeos && current_cpu == "arm") && !is_mac) {
+    if (!(is_chromeos && cpu_arch == "arm") && !is_mac) {
       # TODO(jochen): Enable this on chromeos on arm. http://crbug.com/356580
       ldflags += [ "-Wl,--fatal-warnings" ]
     }
 
     # Common options for AddressSanitizer, LeakSanitizer, ThreadSanitizer and
     # MemorySanitizer
     if (using_sanitizer) {
       cflags += [
         "-fno-omit-frame-pointer",
         "-gline-tables-only",
@@ skipping 30 matching lines @@
                              "value") ]
   }
 
   # Mac-specific compiler flags setup.
   # ----------------------------------
   if (is_mac || is_ios) {
     # These flags are shared between the C compiler and linker.
     common_mac_flags = []
 
     # CPU architecture.
-    if (current_cpu == "x64") {
+    if (cpu_arch == "x64") {
       common_mac_flags += [
         "-arch",
         "x86_64",
       ]
-    } else if (current_cpu == "x86") {
+    } else if (cpu_arch == "x86") {
       common_mac_flags += [
         "-arch",
         "i386",
       ]
     }
 
     cflags += common_mac_flags
 
     # Without this, the constructors and destructors of a C++ object inside
     # an Objective C struct won't be called, which is very bad.
@@ skipping 24 matching lines @@
       if (enable_full_stack_frames_for_profiling) {
         cflags += [
           "-fno-inline",
           "-fno-optimize-sibling-calls",
         ]
       }
     }
 
     # CPU architecture. We may or may not be doing a cross compile now, so for
     # simplicity we always explicitly set the architecture.
-    if (current_cpu == "x64") {
+    if (cpu_arch == "x64") {
       cflags += [
         "-m64",
         "-march=x86-64",
       ]
       ldflags += [ "-m64" ]
-    } else if (current_cpu == "x86") {
+    } else if (cpu_arch == "x86") {
       cflags += [ "-m32" ]
       ldflags += [ "-m32" ]
       if (is_clang) {
         cflags += [
           # Else building libyuv gives clang's register allocator issues,
           # see llvm.org/PR15798 / crbug.com/233709
           "-momit-leaf-frame-pointer",
 
           # Align the stack on 16-byte boundaries, http://crbug.com/418554.
           "-mstack-alignment=16",
           "-mstackrealign",
         ]
       }
-    } else if (current_cpu == "arm") {
+    } else if (cpu_arch == "arm") {
       # Don't set the compiler flags for the WebView build. These will come
       # from the Android build system.
       if (!is_android_webview_build) {
         cflags += [
           "-march=$arm_arch",
           "-mfloat-abi=$arm_float_abi",
         ]
         if (arm_tune != "") {
           cflags += [ "-mtune=$arm_tune" ]
         }
@@ skipping 12 matching lines @@
             # compiler (r5-r7). This can be verified using
             # webkit_unit_tests' WTF.Checked_int8_t test.
             "-fno-tree-sra",
 
             # The following option is disabled to improve binary
             # size and performance in gcc 4.9.
             "-fno-caller-saves",
           ]
         }
       }
-    } else if (current_cpu == "mipsel") {
+    } else if (cpu_arch == "mipsel") {
       # Don't set the compiler flags for the WebView build. These will come
       # from the Android build system.
       if (!is_android_webview_build) {
         if (mips_arch_variant == "r6") {
           cflags += [
             "-mips32r6",
             "-Wa,-mips32r6",
           ]
           if (is_android) {
             ldflags += [
               "-mips32r6",
               "-Wl,-melf32ltsmip",
             ]
           }
         } else if (mips_arch_variant == "r2") {
           cflags += [
             "-mips32r2",
             "-Wa,-mips32r2",
           ]
         } else if (mips_arch_variant == "r1") {
           cflags += [
             "-mips32",
             "-Wa,-mips32",
           ]
         }
       }
-    } else if (current_cpu == "mips64el") {
+    } else if (cpu_arch == "mips64el") {
       # Don't set the compiler flags for the WebView build. These will come
       # from the Android build system.
       if (!is_android_webview_build) {
         if (mips_arch_variant == "r6") {
           cflags += [
             "-mips64r6",
             "-Wa,-mips64r6",
           ]
           ldflags += [ "-mips64r6" ]
         } else if (mips_arch_variant == "r2") {
@@ skipping 114 matching lines @@
     }
 
     defines += [ "ANDROID" ]
     if (!is_android_webview_build) {
       # The NDK has these things, but doesn't define the constants
       # to say that it does. Define them here instead.
       defines += [ "HAVE_SYS_UIO_H" ]
     }
 
     # Use gold for Android for most CPU architectures.
-    if (current_cpu == "x86" || current_cpu == "x64" || current_cpu == "arm") {
+    if (cpu_arch == "x86" || cpu_arch == "x64" || cpu_arch == "arm") {
       ldflags += [ "-fuse-ld=gold" ]
       if (is_clang) {
         # Let clang find the ld.gold in the NDK.
         ldflags += [ "--gcc-toolchain=" +
                      rebase_path(android_toolchain_root, root_build_dir) ]
       }
     }
 
     ldflags += [
       "-Wl,--no-undefined",
 
-      # Don't allow visible symbols from libgcc or stlport to be
-      # re-exported.
-      "-Wl,--exclude-libs=libgcc.a",
-      "-Wl,--exclude-libs=libstlport_static.a",
-
-      # Don't allow visible symbols from libraries that contain
-      # assembly code with symbols that aren't hidden properly.
-      # http://crbug.com/448386
-      "-Wl,--exclude-libs=libvpx_assembly_arm.a",
+      # Don't export symbols from statically linked libraries.
+      "-Wl,--exclude-libs=ALL",
     ]
-    if (current_cpu == "arm") {
+    if (cpu_arch == "arm") {
       ldflags += [
         # Enable identical code folding to reduce size.
         "-Wl,--icf=safe",
       ]
     }
 
     if (is_clang) {
-      if (current_cpu == "arm") {
+      if (cpu_arch == "arm") {
         cflags += [ "-target arm-linux-androideabi" ]
         ldflags += [ "-target arm-linux-androideabi" ]
-      } else if (current_cpu == "x86") {
+      } else if (cpu_arch == "x86") {
         cflags += [ "-target x86-linux-androideabi" ]
         ldflags += [ "-target x86-linux-androideabi" ]
       }
     }
   }
 }
 
 config("compiler_arm_fpu") {
-  if (current_cpu == "arm" && !is_android_webview_build) {
+  if (cpu_arch == "arm" && !is_android_webview_build) {
     cflags = [ "-mfpu=$arm_fpu" ]
   }
 }
 
 # runtime_library -------------------------------------------------------------
 #
 # Sets the runtime library and associated options.
 #
 # How do you determine what should go in here vs. "compiler" above? Consider if
 # a target might choose to use a different runtime library (ignore for a moment
@@ skipping 77 matching lines @@
     cflags += [ "-isystem" +
                 rebase_path("$android_stlport_root/stlport", root_build_dir) ]
     lib_dirs += [ "$android_stlport_root/libs/$android_app_abi" ]
 
     if (component_mode == "shared_library") {
       libs += [ "stlport_shared" ]
     } else {
       libs += [ "stlport_static" ]
     }
 
-    if (current_cpu == "mipsel") {
+    if (cpu_arch == "mipsel") {
       libs += [
         # ld linker is used for mips Android, and ld does not accept library
         # absolute path prefixed by "-l"; Since libgcc does not exist in mips
         # sysroot the proper library will be linked.
         # TODO(gordanac): Remove once gold linker is used for mips Android.
         "gcc",
       ]
     } else {
       libs += [
         # Manually link the libgcc.a that the cross compiler uses. This is
@@ skipping 246 matching lines @@
         # See comment for -Wno-c++11-narrowing.
         "-Wno-narrowing",
 
         # TODO(thakis): Remove, http://crbug.com/263960
         "-Wno-literal-suffix",
       ]
     }
 
     # Suppress warnings about ABI changes on ARM (Clang doesn't give this
     # warning).
-    if (current_cpu == "arm" && !is_clang) {
+    if (cpu_arch == "arm" && !is_clang) {
       cflags += [ "-Wno-psabi" ]
     }
 
     if (is_android) {
       # Disable any additional warnings enabled by the Android build system but
       # which chromium does not build cleanly with (when treating warning as
       # errors).
       cflags += [
         "-Wno-extra",
         "-Wno-ignored-qualifiers",
@@ skipping 23 matching lines @@
 
 # This will generate warnings when using Clang if code generates exit-time
 # destructors, which will slow down closing the program.
 # TODO(thakis): Make this a blacklist instead, http://crbug.com/101600
 config("wexit_time_destructors") {
   if (is_clang) {
     cflags = [ "-Wexit-time-destructors" ]
   }
 }
 
-# On Windows compiling on x64, VC will issue a warning when converting
-# size_t to int because it will truncate the value. Our code should not have
-# these warnings and one should use a static_cast or a checked_cast for the
-# conversion depending on the case. However, a lot of code still needs to be
-# fixed. Apply this config to such targets to disable the warning.
-#
-# Note that this can be applied regardless of platform and architecture to
-# clean up the call sites. This will only apply the flag when necessary.
-config("no_size_t_to_int_warning") {
-  if (is_win && current_cpu == "x64") {
-    cflags = [ "/wd4267" ]
-  }
-}
-
 # Optimization -----------------------------------------------------------------
 #
 # Note that BUILDCONFIG.gn sets up a variable "default_optimization_config"
 # which it will assign to the config it implicitly applies to every target. If
 # you want to override the optimization level for your target, remove this
 # config (which will expand differently for debug or release builds), and then
 # add back the one you want to override it with:
 #
 #   configs -= default_optimization_config
 #   configs += [ "//build/config/compiler/optimize_max" ]
@@ skipping 159 matching lines @@
       cflags += [ "-gsplit-dwarf" ]
     }
   }
 }
 
 config("no_symbols") {
   if (!is_win) {
     cflags = [ "-g0" ]
   }
 }