Update from https://crrev.com/327068

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") {
   import("//build/config/arm.gni")
 }
 if (current_cpu == "mipsel" || current_cpu == "mips64el") {
   import("//build/config/mips.gni")
@@ skipping 147 matching lines @@
   }
 
   if (is_clang && !is_win && !is_nacl) {
     # This is here so that all files get recompiled after a clang roll and
     # when turning clang on or off. (defines are passed via the command line,
     # and build system rebuild things when their commandline changes). Nothing
     # should ever read this define.
     defines += [ "CR_CLANG_REVISION=" +
                  exec_script("//tools/clang/scripts/posix-print-revision.py",
                              [],
-                             "value") ]
+                             "trim string") ]
   }
 
   # 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") {
       common_mac_flags += [
         "-arch",
         "x86_64",
       ]
     } else if (current_cpu == "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.
     cflags_objcc = [ "-fobjc-call-cxx-cdtors" ]
 
     cflags_c += [ "-std=c99" ]
-    cflags_cc += [ "-std=gnu++11" ]
 
     ldflags += common_mac_flags
   } else if (is_posix) {
     # Non-Mac Posix compiler flags setup.
     # -----------------------------------
-    if (gcc_version >= 48) {
-      cflags_cc += [ "-std=gnu++11" ]
-    }
-
     if (enable_profiling && !is_debug) {
       # The GYP build spams this define into every compilation unit, as we do
       # here, but it only appears to be used in base and a couple other places.
       # TODO(abarth): Should we move this define closer to where it's used?
       defines += [ "ENABLE_PROFILING" ]
 
       cflags += [
         "-fno-omit-frame-pointer",
         "-g",
       ]
@@ skipping 22 matching lines @@
           # 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") {
-      # 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" ]
+      }
+      if (arm_use_thumb) {
+        cflags += [ "-mthumb" ]
+        if (is_android && !is_clang) {  # Clang doesn't support this option.
+          cflags += [ "-mthumb-interwork" ]
+        }
+      }
+      if (!is_clang) {
+        # Clang doesn't support these flags.
         cflags += [
-          "-march=$arm_arch",
-          "-mfloat-abi=$arm_float_abi",
+          # The tree-sra optimization (scalar replacement for
+          # aggregates enabling subsequent optimizations) leads to
+          # invalid code generation when using the Android NDK's
+          # 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",
         ]
-        if (arm_tune != "") {
-          cflags += [ "-mtune=$arm_tune" ]
-        }
-        if (arm_use_thumb) {
-          cflags += [ "-mthumb" ]
-          if (is_android && !is_clang) {  # Clang doesn't support this option.
-            cflags += [ "-mthumb-interwork" ]
-          }
-        }
-        if (!is_clang) {
-          # Clang doesn't support these flags.
-          cflags += [
-            # The tree-sra optimization (scalar replacement for
-            # aggregates enabling subsequent optimizations) leads to
-            # invalid code generation when using the Android NDK's
-            # 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") {
+      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",
+        ]
+        if (mips_float_abi == "hard" && mips_fpu_mode != "") {
+          cflags += [ "-m$mips_fpu_mode" ]
+        }
+      } else if (mips_arch_variant == "r1") {
+        cflags += [
+          "-mips32",
+          "-Wa,-mips32",
+        ]
       }
-    } else if (current_cpu == "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",
-          ]
-          if (mips_float_abi == "hard" && mips_fpu_mode != "") {
-            cflags += [ "-m$mips_fpu_mode" ]
-          }
-        } else if (mips_arch_variant == "r1") {
-          cflags += [
-            "-mips32",
-            "-Wa,-mips32",
-          ]
-        }
 
-        if (mips_dsp_rev == 1) {
-          cflags += [ "-mdsp" ]
-        } else if (mips_dsp_rev == 2) {
-          cflags += [ "-mdspr2" ]
-        }
+      if (mips_dsp_rev == 1) {
+        cflags += [ "-mdsp" ]
+      } else if (mips_dsp_rev == 2) {
+        cflags += [ "-mdspr2" ]
+      }
 
-        cflags += [ "-m${mips_float_abi}-float" ]
-      }
+      cflags += [ "-m${mips_float_abi}-float" ]
     } else if (current_cpu == "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") {
-          cflags += [
-            "-mips64r2",
-            "-Wa,-mips64r2",
-          ]
-          ldflags += [ "-mips64r2" ]
-        }
+      if (mips_arch_variant == "r6") {
+        cflags += [
+          "-mips64r6",
+          "-Wa,-mips64r6",
+        ]
+        ldflags += [ "-mips64r6" ]
+      } else if (mips_arch_variant == "r2") {
+        cflags += [
+          "-mips64r2",
+          "-Wa,-mips64r2",
+        ]
+        ldflags += [ "-mips64r2" ]
       }
     }
 
     defines += [ "_FILE_OFFSET_BITS=64" ]
 
+    if (!is_android) {
+      defines += [
+        "_LARGEFILE_SOURCE",
+        "_LARGEFILE64_SOURCE",
+      ]
+    }
+
     # Omit unwind support in official builds to save space. We can use breakpad
     # for these builds.
     if (is_chrome_branded && is_official_build) {
       cflags += [
         "-fno-unwind-tables",
         "-fno-asynchronous-unwind-tables",
       ]
     } else {
       cflags += [ "-funwind-tables" ]
     }
@@ skipping 60 matching lines @@
   if (linux_use_bundled_binutils) {
     binutils_path = rebase_path("//third_party/binutils/Linux_x64/Release/bin",
                                 root_build_dir)
     cflags += [ "-B$binutils_path" ]
   }
 
   # Clang-specific compiler flags setup.
   # ------------------------------------
   if (is_clang) {
     cflags += [ "-fcolor-diagnostics" ]
+  }
+
+  # C++11 compiler flags setup.
+  # ---------------------------
+  if (is_linux || is_android || is_nacl) {
+    # gnu++11 instead of c++11 is needed because some code uses typeof() (a
+    # GNU extension).
+    # TODO(thakis): Eventually switch this to c++11 instead,
+    # http://crbug.com/427584
     cflags_cc += [ "-std=gnu++11" ]
+  } else if (!is_win) {
+    cflags_cc += [ "-std=c++11" ]
   }
 
   # Android-specific flags setup.
   # -----------------------------
   if (is_android) {
     cflags += [
       "-ffunction-sections",
       "-funwind-tables",
       "-fno-short-enums",
     ]
     if (!is_clang) {
       # Clang doesn't support these flags.
       cflags += [ "-finline-limit=64" ]
     }
-    if (is_android_webview_build) {
-      # Android predefines this as 1; undefine it here so Chromium can redefine
-      # it later to be 2 for chromium code and unset for third party code. This
-      # works because cflags are added before defines.
-      # TODO(brettw) the above comment seems incorrect. We specify defines
-      # before cflags on our compiler command lines.
-      cflags += [ "-U_FORTIFY_SOURCE" ]
-    }
-
     if (is_asan) {
       # Android build relies on -Wl,--gc-sections removing unreachable code.
       # ASan instrumentation for globals inhibits this and results in a library
       # with unresolvable relocations.
       # TODO(eugenis): find a way to reenable this.
       cflags += [ "-mllvm -asan-globals=0" ]
     }
 
     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" ]
-    }
+
+    # 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") {
       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) ]
       }
     }
@@ skipping 24 matching lines @@
         ldflags += [ "-target arm-linux-androideabi" ]
       } else if (current_cpu == "x86") {
         cflags += [ "-target x86-linux-androideabi" ]
         ldflags += [ "-target x86-linux-androideabi" ]
       }
     }
   }
 }
 
 config("compiler_arm_fpu") {
-  if (current_cpu == "arm" && !is_android_webview_build) {
+  if (current_cpu == "arm") {
     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 52 matching lines @@
     }
 
     defines += [
       "USE_STLPORT=1",
       "_STLP_USE_PTR_SPECIALIZATIONS=1",
       "__GNU_SOURCE=1",  # Necessary for clone().
     ]
 
     # TODO(jdduke) Re-enable on mips after resolving linking
     # issues with libc++ (crbug.com/456380).
-    if (cpu_arch != "mipsel" && cpu_arch != "mips64el") {
+    if (current_cpu != "mipsel" && current_cpu != "mips64el") {
       ldflags += [ "-Wl,--warn-shared-textrel" ]
     }
     ldflags += [ "-nostdlib" ]
 
     # NOTE: The stlport header include paths below are specified in cflags
     # rather than include_dirs because they need to come after include_dirs.
     # Think of them like system headers, but don't use '-isystem' because the
     # arm-linux-androideabi-4.4.3 toolchain (circa Gingerbread) will exhibit
     # strange errors. The include ordering here is important; change with
     # caution.
@@ skipping 90 matching lines @@
     cflags += [
       # Don't warn about printf format problems. This is off by default in gcc
       # but on in Ubuntu's gcc(!).
       "-Wno-format",
     ]
     cflags_cc += [
       # Don't warn about hash_map in third-party code.
       "-Wno-deprecated",
     ]
   }
-
-  if (is_android_webview_build) {
-    # There is a class of warning which:
-    #  1) Android always enables and also treats as errors
-    #  2) Chromium ignores in third party code
-    # So we re-enable those warnings when building Android.
-    cflags += [
-      "-Wno-address",
-      "-Wno-format-security",
-      "-Wno-return-type",
-      "-Wno-sequence-point",
-    ]
-    cflags_cc += [ "-Wno-non-virtual-dtor" ]
-  }
 }
 
 # rtti ------------------------------------------------------------------------
 #
 # Allows turning Run-Time Type Identification on or off.
 
 config("rtti") {
   if (is_win) {
     cflags_cc = [ "/GR" ]
   }
@@ skipping 265 matching lines @@
   ]
   common_optimize_on_ldflags = []
 
   if (is_android) {
     if (!using_sanitizer) {
       common_optimize_on_cflags += [ "-fomit-frame-pointer" ]
     }
 
     # TODO(jdduke) Re-enable on mips after resolving linking
     # issues with libc++ (crbug.com/456380).
-    if (cpu_arch != "mipsel" && cpu_arch != "mips64el") {
+    if (current_cpu != "mipsel" && current_cpu != "mips64el") {
       common_optimize_on_ldflags += [
         # Warn in case of text relocations.
         "-Wl,--warn-shared-textrel",
       ]
     }
   }
 
   if (is_mac) {
     if (symbol_level == 2) {
       # Mac dead code stripping requires symbols.
@@ skipping 113 matching lines @@
       cflags += [ "-gsplit-dwarf" ]
     }
   }
 }
 
 config("no_symbols") {
   if (!is_win) {
     cflags = [ "-g0" ]
   }
 }