Replace the asan_coverage GYP flag with sanitizer_coverage which is to be used with other sanitizer…

content/zygote/zygote_main_linux.cc

 // 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.
 
 #include "content/zygote/zygote_main.h"
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
@@ skipping 47 matching lines @@
 
 #if defined(ENABLE_PLUGINS)
 #include "content/common/pepper_plugin_list.h"
 #include "content/public/common/pepper_plugin_info.h"
 #endif
 
 #if defined(ENABLE_WEBRTC)
 #include "third_party/libjingle/overrides/init_webrtc.h"
 #endif
 
-#if defined(ADDRESS_SANITIZER)
-#include <sanitizer/asan_interface.h>
+#if defined(SANITIZER_COVERAGE)
+#include <sanitizer/common_interface_defs.h>
 #endif
 
 namespace content {
 
 namespace {
 
 void CloseFds(const std::vector<int>& fds) {
   for (const auto& it : fds) {
     PCHECK(0 == IGNORE_EINTR(close(it)));
   }
@@ skipping 328 matching lines @@
 
 static void EnterNamespaceSandbox(LinuxSandbox* linux_sandbox,
                                   base::Closure* post_fork_parent_callback) {
   linux_sandbox->EngageNamespaceSandbox();
 
   if (getpid() == 1) {
     CHECK(CreateInitProcessReaper(post_fork_parent_callback));
   }
 }
 
-#if defined(ADDRESS_SANITIZER)
+#if defined(SANITIZER_COVERAGE)
 const size_t kSanitizerMaxMessageLength = 1 * 1024 * 1024;
 
 // A helper process which collects code coverage data from the renderers over a
 // socket and dumps it to a file. See http://crbug.com/336212 for discussion.
 static void SanitizerCoverageHelper(int socket_fd, int file_fd) {
   scoped_ptr<char[]> buffer(new char[kSanitizerMaxMessageLength]);
   while (true) {
     ssize_t received_size = HANDLE_EINTR(
         recv(socket_fd, buffer.get(), kSanitizerMaxMessageLength, 0));
     PCHECK(received_size >= 0);
@@ skipping 33 matching lines @@
     CloseFds(extra_fds_to_close);
     SanitizerCoverageHelper(child_fd, file_fd.get());
     _exit(0);
   } else {
     // In the parent.
     PCHECK(0 == IGNORE_EINTR(close(child_fd)));
     return pid;
   }
 }
 
-#endif  // defined(ADDRESS_SANITIZER)
+#endif  // defined(SANITIZER_COVERAGE)
 
 static void EnterLayerOneSandbox(LinuxSandbox* linux_sandbox,
                                  const bool using_layer1_sandbox,
                                  base::Closure* post_fork_parent_callback) {
   DCHECK(linux_sandbox);
 
   ZygotePreSandboxInit();
 
   // Check that the pre-sandbox initialization didn't spawn threads.
 #if !defined(THREAD_SANITIZER)
@@ skipping 14 matching lines @@
 
 bool ZygoteMain(const MainFunctionParams& params,
                 ScopedVector<ZygoteForkDelegate> fork_delegates) {
   g_am_zygote_or_renderer = true;
   sandbox::InitLibcUrandomOverrides();
 
   std::vector<int> fds_to_close_post_fork;
 
   LinuxSandbox* linux_sandbox = LinuxSandbox::GetInstance();
 
-#if defined(ADDRESS_SANITIZER)
+#if defined(SANITIZER_COVERAGE)
   const std::string sancov_file_name =
       "zygote." + base::Uint64ToString(base::RandUint64());
   base::ScopedFD sancov_file_fd(
       __sanitizer_maybe_open_cov_file(sancov_file_name.c_str()));
   int sancov_socket_fds[2] = {-1, -1};
   CreateSanitizerCoverageSocketPair(sancov_socket_fds);
   linux_sandbox->sanitizer_args()->coverage_sandboxed = 1;
   linux_sandbox->sanitizer_args()->coverage_fd = sancov_socket_fds[1];
   linux_sandbox->sanitizer_args()->coverage_max_block_size =
       kSanitizerMaxMessageLength;
   // Zygote termination will block until the helper process exits, which will
   // not happen until the write end of the socket is closed everywhere. Make
   // sure the init process does not hold on to it.
   fds_to_close_post_fork.push_back(sancov_socket_fds[0]);
   fds_to_close_post_fork.push_back(sancov_socket_fds[1]);
-#endif
+#endif  // SANITIZER_COVERAGE
 
   // Skip pre-initializing sandbox under --no-sandbox for crbug.com/444900.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kNoSandbox)) {
     // This will pre-initialize the various sandboxes that need it.
     linux_sandbox->PreinitializeSandbox();
   }
 
   const bool using_setuid_sandbox =
       linux_sandbox->setuid_sandbox_client()->IsSuidSandboxChild();
@@ skipping 29 matching lines @@
 
   // Turn on the first layer of the sandbox if the configuration warrants it.
   EnterLayerOneSandbox(linux_sandbox, using_layer1_sandbox,
                        &post_fork_parent_callback);
 
   // Extra children and file descriptors created that the Zygote must have
   // knowledge of.
   std::vector<pid_t> extra_children;
   std::vector<int> extra_fds;
 
-#if defined(ADDRESS_SANITIZER)
+#if defined(SANITIZER_COVERAGE)
   pid_t sancov_helper_pid = ForkSanitizerCoverageHelper(
       sancov_socket_fds[0], sancov_socket_fds[1], sancov_file_fd.Pass(),
       sandbox_fds_to_close_post_fork);
   // It's important that the zygote reaps the helper before dying. Otherwise,
   // the destruction of the PID namespace could kill the helper before it
   // completes its I/O tasks. |sancov_helper_pid| will exit once the last
   // renderer holding the write end of |sancov_socket_fds| closes it.
   extra_children.push_back(sancov_helper_pid);
   // Sanitizer code in the renderers will inherit the write end of the socket
   // from the zygote. We must keep it open until the very end of the zygote's
   // lifetime, even though we don't explicitly use it.
   extra_fds.push_back(sancov_socket_fds[1]);
-#endif
+#endif  // SANITIZER_COVERAGE
 
   const int sandbox_flags = linux_sandbox->GetStatus();
 
   const bool setuid_sandbox_engaged = sandbox_flags & kSandboxLinuxSUID;
   CHECK_EQ(using_setuid_sandbox, setuid_sandbox_engaged);
 
   const bool namespace_sandbox_engaged = sandbox_flags & kSandboxLinuxUserNS;
   CHECK_EQ(using_namespace_sandbox, namespace_sandbox_engaged);
 
   Zygote zygote(sandbox_flags, fork_delegates.Pass(), extra_children,
                 extra_fds);
   // This function call can return multiple times, once per fork().
   return zygote.ProcessRequests();
 }
 
 }  // namespace content