Roll DEPS for Breakpad r1020:1050.

chrome/app/breakpad_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.
 
 // For linux_syscall_support.h. This makes it safe to call embedded system
 // calls when in seccomp mode.
 #define SYS_SYSCALL_ENTRYPOINT "playground$syscallEntryPoint"
 
 #include "chrome/app/breakpad_linux.h"
 
@@ skipping 38 matching lines @@
 #include <sys/stat.h>
 
 #include "base/android/build_info.h"
 #include "base/android/path_utils.h"
 #include "third_party/lss/linux_syscall_support.h"
 #else
 #include "sandbox/linux/seccomp-legacy/linux_syscall_support.h"
 #endif
 
 #if defined(ADDRESS_SANITIZER)
-#include <ucontext.h> // for getcontext().
+#include <ucontext.h>  // for getcontext().
 #endif
 
 #if defined(OS_ANDROID)
 #define STAT_STRUCT struct stat
 #define FSTAT_FUNC fstat
 #else
 #define STAT_STRUCT struct kernel_stat
 #define FSTAT_FUNC sys_fstat
 #endif
 
@@ skipping 65 matching lines @@
 
   unsigned len = 0;
   while (i) {
     len++;
     i /= 10;
   }
 
   return len;
 }
 
-// uint64_t version of my_itos() from
+// uint64_t version of my_uitos() from
 // breakpad/src/common/linux/linux_libc_support.h. Convert a non-negative
 // integer to a string (not null-terminated).
 void my_uint64tos(char* output, uint64_t i, unsigned i_len) {
   for (unsigned index = i_len; index; --index, i /= 10)
     output[index - 1] = '0' + (i % 10);
 }
 
 #if defined(OS_ANDROID)
 char* my_strncpy(char* dst, const char* src, size_t len) {
   int i = len;
@@ skipping 141 matching lines @@
                                      size_t chunk_size,
                                      bool strip_trailing_spaces) {
   if (chunk_size > kMaxCrashChunkSize)
     return;
 
   unsigned i = 0;
   size_t done = 0, msg_length = msg_data_size;
 
   while (msg_length) {
     char num[16];
-    const unsigned num_len = my_int_len(++i);
-    my_itos(num, i, num_len);
+    const unsigned num_len = my_uint_len(++i);
+    my_uitos(num, i, num_len);
 
     size_t chunk_len = std::min(chunk_size, msg_length);
 
     AddString(g_form_data_msg);
     AddItem(msg_type, msg_type_size);
     AddItem(num, num_len);
     AddString(g_quote_msg);
     AddString(g_rn);
     AddString(g_rn);
     if (strip_trailing_spaces) {
@@ skipping 359 matching lines @@
   my_memset(*file_data, 0xf, st.st_size);
 
   *size = st.st_size;
   sys_read(*fd, *file_data, *size);
   IGNORE_RET(sys_close(*fd));
 }
 
 void HandleCrashDump(const BreakpadInfo& info) {
   int dumpfd;
   size_t dump_size;
-  uint8_t *dump_data;
+  uint8_t* dump_data;
   google_breakpad::PageAllocator allocator;
   LoadDataFromFile(allocator, info, info.filename,
                    &dumpfd, &dump_data, &dump_size);
 #if defined(ADDRESS_SANITIZER)
   int logfd;
   size_t log_size;
-  uint8_t *log_data;
+  uint8_t* log_data;
   // Load the AddressSanitizer log into log_data.
   LoadDataFromFile(allocator, info, info.log_filename,
                    &logfd, &log_data, &log_size);
 #endif
 
   // We need to build a MIME block for uploading to the server. Since we are
   // going to fork and run wget, it needs to be written to a temp file.
   const int ufd = sys_open("/dev/urandom", O_RDONLY, 0);
   if (ufd < 0) {
     static const char msg[] = "Cannot upload crash dump because /dev/urandom"
@@ skipping 596 matching lines @@
   logging::SetDumpWithoutCrashingFunction(&DumpProcess);
 #if defined(ADDRESS_SANITIZER)
   // Register the callback for AddressSanitizer error reporting.
   __asan_set_error_report_callback(AsanLinuxBreakpadCallback);
 #endif
 }
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }