Fix stack_trace_unittest for cobalt.

b/316403754

Change-Id: I8da6ff532c4c78acb44dfcf7360c26a21887ad85

base/BUILD.gn

@@ -1717,6 +1717,12 @@ component("base") {
       ]
     }
 
+    if (use_cobalt_customizations) {
+      sources += [
+        "process/launch_starboard.cc",
+      ]
+    }
+
     if (!use_cobalt_customizations && is_posix && !is_android) {
       sources += [ "debug/stack_trace_posix.cc" ]
     }
@@ -1743,6 +1749,13 @@ component("base") {
       ]
     }
 
+    if (!use_blink && use_cobalt_customizations) {
+      sources += [
+        "process/launch.cc",
+        "process/launch.h",
+      ]
+    }
+
     if (is_linux || is_chromeos) {
       sources += [
         "base_paths_posix.cc",
@@ -3171,7 +3184,7 @@ test("base_unittests") {
     "debug/debugger_unittest.cc",
     "debug/dump_without_crashing_unittest.cc",
 
-    # "debug/stack_trace_unittest.cc",
+    "debug/stack_trace_unittest.cc",
     "debug/task_trace_unittest.cc",
     "environment_unittest.cc",
 

base/debug/stack_trace_starboard.cc

@@ -61,8 +61,45 @@ class StreamBacktraceOutputHandler : public BacktraceOutputHandler {
   StreamBacktraceOutputHandler& operator=(const StreamBacktraceOutputHandler&) = delete;
 };
 
+void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
+  char buf[1024] = {'\0'};
+  handler->HandleOutput(" [0x");
+  internal::itoa_r(reinterpret_cast<intptr_t>(pointer), buf, sizeof(buf), 16, 0);
+  handler->HandleOutput(buf);
+  handler->HandleOutput("]");
+}
+
+void ProcessBacktrace(void* const* trace,
+                      int size,
+                      const char* prefix_string,
+                      BacktraceOutputHandler* handler) {
+  for (int i = 0; i < size; ++i) {
+    if (prefix_string)
+      handler->HandleOutput(prefix_string);
+    handler->HandleOutput("\t");
+
+    char buf[1024] = {'\0'};
+
+    // Subtract by one as return address of function may be in the next
+    // function when a function is annotated as noreturn.
+    void* address = static_cast<char*>(trace[i]) - 1;
+    if (SbSystemSymbolize(address, buf, sizeof(buf))) {
+      handler->HandleOutput(buf);
+    } else {
+      handler->HandleOutput("<unknown>");
+    }
+
+    OutputPointer(trace[i], handler);
+    handler->HandleOutput("\n");
+  }
+}
+
+}  // namespace
+
+namespace internal {
+
 // NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-char* itoa_r(intptr_t i, char* buf, size_t sz, int base) {
+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)
@@ -96,13 +133,16 @@ char* itoa_r(intptr_t i, char* buf, size_t sz, int base) {
     // Make sure there is still enough space left in our output buffer.
     if (++n > sz) {
       buf[0] = '\000';
-      return NULL;
+      return nullptr;
     }
 
     // Output the next digit.
-    *ptr++ = "0123456789abcdef"[j % base];
-    j /= base;
-  } while (j);
+    *ptr++ = "0123456789abcdef"[j % static_cast<uintptr_t>(base)];
+    j /= static_cast<uintptr_t>(base);
+
+    if (padding > 0)
+      padding--;
+  } while (j > 0 || padding > 0);
 
   // Terminate the output with a NUL character.
   *ptr = '\000';
@@ -119,40 +159,7 @@ char* itoa_r(intptr_t i, char* buf, size_t sz, int base) {
   return buf;
 }
 
-void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
-  char buf[1024] = {'\0'};
-  handler->HandleOutput(" [0x");
-  itoa_r(reinterpret_cast<intptr_t>(pointer), buf, sizeof(buf), 16);
-  handler->HandleOutput(buf);
-  handler->HandleOutput("]");
-}
-
-void ProcessBacktrace(void* const* trace,
-                      int size,
-                      const char* prefix_string,
-                      BacktraceOutputHandler* handler) {
-  for (int i = 0; i < size; ++i) {
-    if (prefix_string)
-      handler->HandleOutput(prefix_string);
-    handler->HandleOutput("\t");
-
-    char buf[1024] = {'\0'};
-
-    // Subtract by one as return address of function may be in the next
-    // function when a function is annotated as noreturn.
-    void* address = static_cast<char*>(trace[i]) - 1;
-    if (SbSystemSymbolize(address, buf, sizeof(buf))) {
-      handler->HandleOutput(buf);
-    } else {
-      handler->HandleOutput("<unknown>");
-    }
-
-    OutputPointer(trace[i], handler);
-    handler->HandleOutput("\n");
-  }
-}
-
-}  // namespace
+}  // namespace internal
 
 size_t CollectStackTrace(void** trace, size_t count) {
   // NOTE: This code MUST be async-signal safe (it's used by in-process

base/debug/stack_trace_unittest.cc

@@ -104,7 +104,12 @@ TEST_F(StackTraceTest, TruncatedTrace) {
 
   StackTrace truncated(2);
   truncated.Addresses(&count);
+#if defined(USE_HACKY_COBALT_CHANGES)
+  // Starboard removes removes a stack frame that is extra when not truncated.
+  EXPECT_EQ(1u, count);
+#else
   EXPECT_EQ(2u, count);
+#endif
 }
 #endif  // !defined(OFFICIAL_BUILD) && !defined(NO_UNWIND_TABLES)
 
@@ -157,7 +162,8 @@ TEST_F(StackTraceTest, DebugOutputToStreamWithNullPrefix) {
 #endif  // !defined(__UCLIBC__) && !defined(_AIX)
 
 #if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_ANDROID)
-#if !BUILDFLAG(IS_IOS)
+// Starboard does not support relative file paths, needed by |SpawnChild()|.
+#if !BUILDFLAG(IS_IOS) && !defined(USE_HACKY_COBALT_CHANGES)
 static char* newArray() {
   // Clang warns about the mismatched new[]/delete if they occur in the same
   // function.
@@ -348,7 +354,7 @@ TEST_F(StackTraceTest, MAYBE_TraceStackFramePointers) {
 // sometimes we read fp / pc from the place that previously held
 // uninitialized value.
 // TODO(crbug.com/1132511): Enable this test on Fuchsia.
-#if defined(MEMORY_SANITIZER) || BUILDFLAG(IS_FUCHSIA)
+#if defined(MEMORY_SANITIZER) || BUILDFLAG(IS_FUCHSIA) || defined(STARBOARD) && defined(ADDRESS_SANITIZER)
 #define MAYBE_TraceStackFramePointersFromBuffer \
   DISABLED_TraceStackFramePointersFromBuffer
 #else
@@ -421,6 +427,7 @@ TEST(CheckExitCodeAfterSignalHandlerDeathTest,
 
 #endif  // #if !defined(ADDRESS_SANITIZER) && !defined(UNDEFINED_SANITIZER)
 
+#if !defined(USE_HACKY_COBALT_CHANGES)
 TEST(CheckExitCodeAfterSignalHandlerDeathTest, CheckSIGILL) {
   auto const raise_sigill = []() {
 #if defined(ARCH_CPU_X86_FAMILY)
@@ -434,6 +441,7 @@ TEST(CheckExitCodeAfterSignalHandlerDeathTest, CheckSIGILL) {
 
   EXPECT_EXIT(raise_sigill(), ::testing::KilledBySignal(SIGILL), "");
 }
+#endif  // !defined(USE_HACKY_COBALT_CHANGES)
 
 #endif  // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_ANDROID)
 

base/process/launch_starboard.cc

@@ -0,0 +1,26 @@
+// Copyright 2024 The Cobalt Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/process/launch.h"
+
+namespace base {
+
+void RaiseProcessToHighPriority() {
+  // Impossible on iOS. Do nothing.
+}
+
+bool GetAppOutput(const CommandLine& cl, std::string* output) {
+  return false;
+}
+
+bool GetAppOutputAndError(const CommandLine& cl, std::string* output) {
+  return false;
+}
+
+Process LaunchProcess(const CommandLine& cmdline,
+                      const LaunchOptions& options) {
+  return Process();
+}
+
+}  // namespace base

base/process/process_starboard.cc

@@ -43,6 +43,14 @@ bool Process::IsProcessBackgrounded() const {
   return false;
 }
 
+bool Process::IsValid() const {
+  return true;
+}
+
+bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const {
+  return false;
+}
+
 Time Process::CreationTime() const {
   return Time();
 }

base/test/BUILD.gn

@@ -300,6 +300,12 @@ static_library("test_support") {
     ]
   }
 
+  if (!use_blink && is_starboard) {
+    sources += [
+      "multiprocess_test.cc",
+    ]
+  }
+
   if (enable_base_tracing) {
     sources += [
       "../trace_event/trace_config_memory_test_util.h",