Cleanup: Correctly spell success(ful).

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 455 matching lines @@
       : is_initialized_(false) {
     Init();
   }
 
   ~SandboxSymbolizeHelper() {
     UnregisterCallback();
     CloseObjectFiles();
   }
 
   // Returns a O_RDONLY file descriptor for |file_path| if it was opened
-  // sucessfully during the initialization.  The file is repositioned at
+  // successfully 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(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
@@ skipping 247 matching lines @@
 #if !defined(__UCLIBC__)
 void StackTrace::OutputToStream(std::ostream* os) const {
   StreamBacktraceOutputHandler handler(os);
   ProcessBacktrace(trace_, count_, &handler);
 }
 #endif
 
 namespace internal {
 
 // NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-char *itoa_r(intptr_t i, char *buf, size_t sz, int base, size_t padding) {
+char* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding) {
   // Make sure we can write at least one NUL byte.
   size_t n = 1;
   if (n > sz)
     return NULL;
 
   if (base < 2 || base > 16) {
     buf[0] = '\000';
     return NULL;
   }
 
-  char *start = buf;
+  char* start = buf;
 
   uintptr_t j = i;
 
   // Handle negative numbers (only for base 10).
   if (i < 0 && base == 10) {
     // This does "j = -i" while avoiding integer overflow.
     j = static_cast<uintptr_t>(-(i + 1)) + 1;
 
     // Make sure we can write the '-' character.
     if (++n > sz) {
       buf[0] = '\000';
       return NULL;
     }
     *start++ = '-';
   }
 
   // Loop until we have converted the entire number. Output at least one
   // character (i.e. '0').
-  char *ptr = start;
+  char* ptr = start;
   do {
     // Make sure there is still enough space left in our output buffer.
     if (++n > sz) {
       buf[0] = '\000';
       return NULL;
     }
 
     // Output the next digit.
     *ptr++ = "0123456789abcdef"[j % base];
     j /= base;
@@ skipping 14 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base