Print stack traces in child processes when browser tests failed.

base/debug/stack_trace_posix.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 "base/debug/stack_trace.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
@@ skipping 494 matching lines @@
   }
 
   // Returns a O_RDONLY file descriptor for |file_path| if it was opened
   // sucessfully during the initialization.  The file is repositioned at
   // offset 0.
   // IMPORTANT: This function must be async-signal-safe because it can be
   // called from a signal handler (symbolizing stack frames for a crash).
   int GetFileDescriptor(const char* file_path) {
     int fd = -1;
 
-#if !defined(NDEBUG)
+#if !defined(OFFICIAL_BUILD)
     if (file_path) {
       // The assumption here is that iterating over std::map<std::string, int>
       // using a const_iterator does not allocate dynamic memory, hense it is
       // async-signal-safe.
       std::map<std::string, int>::const_iterator it;
       for (it = modules_.begin(); it != modules_.end(); ++it) {
         if (strcmp((it->first).c_str(), file_path) == 0) {
           // POSIX.1-2004 requires an implementation to guarantee that dup()
           // is async-signal-safe.
           fd = dup(it->second);
           break;
         }
       }
       // POSIX.1-2004 requires an implementation to guarantee that lseek()
       // is async-signal-safe.
       if (fd >= 0 && lseek(fd, 0, SEEK_SET) < 0) {
         // Failed to seek.
         fd = -1;
       }
     }
-#endif  // !defined(NDEBUG)
+#endif  // !defined(OFFICIAL_BUILD)
 
     return fd;
   }
 
   // Searches for the object file (from /proc/self/maps) that contains
   // the specified pc.  If found, sets |start_address| to the start address
   // of where this object file is mapped in memory, sets the module base
   // address into |base_address|, copies the object file name into
   // |out_file_name|, and attempts to open the object file.  If the object
   // file is opened successfully, returns the file descriptor.  Otherwise,
@@ skipping 65 matching lines @@
       return false;
     }
 
     is_initialized_ = true;
     return true;
   }
 
   // Opens all object files and caches their file descriptors.
   void OpenSymbolFiles() {
     // Pre-opening and caching the file descriptors of all loaded modules is
-    // not considered safe for retail builds.  Hence it is only done in debug
-    // builds.  For more details, take a look at: http://crbug.com/341966
-    // Enabling this to release mode would require approval from the security
-    // team.
-#if !defined(NDEBUG)
+    // not safe for production builds.  Hence it is only done in non-official
+    // builds.  For more details, take a look at: http://crbug.com/341966.
+#if !defined(OFFICIAL_BUILD)
     // Open the object files for all read-only executable regions and cache
     // their file descriptors.
     std::vector<MappedMemoryRegion>::const_iterator it;
     for (it = regions_.begin(); it != regions_.end(); ++it) {
       const MappedMemoryRegion& region = *it;
       // Only interesed in read-only executable regions.
       if ((region.permissions & MappedMemoryRegion::READ) ==
               MappedMemoryRegion::READ &&
           (region.permissions & MappedMemoryRegion::WRITE) == 0 &&
           (region.permissions & MappedMemoryRegion::EXECUTE) ==
@@ skipping 11 matching lines @@
           int fd = open(region.path.c_str(), O_RDONLY | O_CLOEXEC);
           if (fd >= 0) {
             modules_.insert(std::make_pair(region.path, fd));
           } else {
             LOG(WARNING) << "Failed to open file: " << region.path
                          << "\n  Error: " << strerror(errno);
           }
         }
       }
     }
-#endif  // !defined(NDEBUG)
+#endif  // !defined(OFFICIAL_BUILD)
   }
 
   // Initializes and installs the symbolization callback.
   void Init() {
     if (CacheMemoryRegions()) {
       OpenSymbolFiles();
       google::InstallSymbolizeOpenObjectFileCallback(
           &OpenObjectFileContainingPc);
     }
   }
 
   // Unregister symbolization callback.
   void UnregisterCallback() {
     if (is_initialized_) {
       google::InstallSymbolizeOpenObjectFileCallback(NULL);
       is_initialized_ = false;
     }
   }
 
   // Closes all file descriptors owned by this instance.
   void CloseObjectFiles() {
-#if !defined(NDEBUG)
+#if !defined(OFFICIAL_BUILD)
     std::map<std::string, int>::iterator it;
     for (it = modules_.begin(); it != modules_.end(); ++it) {
       int ret = IGNORE_EINTR(close(it->second));
       DCHECK(!ret);
       it->second = -1;
     }
     modules_.clear();
-#endif  // !defined(NDEBUG)
+#endif  // !defined(OFFICIAL_BUILD)
   }
 
   // Set to true upon successful initialization.
   bool is_initialized_;
 
-#if !defined(NDEBUG)
+#if !defined(OFFICIAL_BUILD)
   // Mapping from file name to file descriptor.  Includes file descriptors
   // for all successfully opened object files and the file descriptor for
-  // /proc/self/maps.  This code is not safe for release builds so
-  // this is only done for DEBUG builds.
+  // /proc/self/maps.  This code is not safe for production builds.
   std::map<std::string, int> modules_;
-#endif  // !defined(NDEBUG)
+#endif  // !defined(OFFICIAL_BUILD)
 
   // Cache for the process memory regions.  Produced by parsing the contents
   // of /proc/self/maps cache.
   std::vector<MappedMemoryRegion> regions_;
 
   DISALLOW_COPY_AND_ASSIGN(SandboxSymbolizeHelper);
 };
 #endif  // USE_SYMBOLIZE
 
 bool EnableInProcessStackDumpingForSandbox() {
@@ skipping 127 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base