Update Fuchsia-specific code to use the new MX_ error names

runtime/vm/thread_interrupter_fuchsia.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(HOST_OS_FUCHSIA)
 
 #include "vm/thread_interrupter.h"
 
 #include <magenta/process.h>
@@ skipping 22 matching lines @@
 // feature is added for it.
 
 // A scope within which a target thread is suspended. When the scope is exited,
 // the thread is resumed and its handle is closed.
 class ThreadSuspendScope {
  public:
   explicit ThreadSuspendScope(mx_handle_t thread_handle)
       : thread_handle_(thread_handle), suspended_(true) {
     mx_status_t status = mx_task_suspend(thread_handle);
     // If a thread is somewhere where suspend is impossible, mx_task_suspend()
-    // can return ERR_NOT_SUPPORTED.
-    if (status != NO_ERROR) {
+    // can return MX_ERR_NOT_SUPPORTED.
+    if (status != MX_OK) {
       if (FLAG_trace_thread_interrupter) {
         OS::PrintErr("ThreadInterrupter: mx_task_suspend failed: %s\n",
                      mx_status_get_string(status));
       }
       suspended_ = false;
     }
   }
 
   ~ThreadSuspendScope() {
     if (suspended_) {
       mx_status_t status = mx_task_resume(thread_handle_, 0);
-      if (status != NO_ERROR) {
+      if (status != MX_OK) {
         // If we fail to resume a thread, then it's likely the program will
         // hang. Crash instead.
         FATAL1("mx_task_resume failed: %s", mx_status_get_string(status));
       }
     }
     mx_handle_close(thread_handle_);
   }
 
   bool suspended() const { return suspended_; }
 
  private:
   mx_handle_t thread_handle_;
   bool suspended_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(ThreadSuspendScope);
 };
 
 class ThreadInterrupterFuchsia : public AllStatic {
  public:
 #if defined(TARGET_ARCH_X64)
   static bool GrabRegisters(mx_handle_t thread, InterruptedThreadState* state) {
     mx_x86_64_general_regs_t regs;
     uint32_t regset_size;
     mx_status_t status = mx_thread_read_state(
         thread, MX_THREAD_STATE_REGSET0, &regs, sizeof(regs), &regset_size);
-    if (status != NO_ERROR) {
+    if (status != MX_OK) {
       if (FLAG_trace_thread_interrupter) {
         OS::PrintErr("ThreadInterrupter failed to get registers: %s\n",
                      mx_status_get_string(status));
       }
       return false;
     }
     state->pc = static_cast<uintptr_t>(regs.rip);
     state->fp = static_cast<uintptr_t>(regs.rbp);
     state->csp = static_cast<uintptr_t>(regs.rsp);
     state->dsp = static_cast<uintptr_t>(regs.rsp);
     return true;
   }
 #elif defined(TARGET_ARCH_ARM64)
   static bool GrabRegisters(mx_handle_t thread, InterruptedThreadState* state) {
     mx_arm64_general_regs_t regs;
     uint32_t regset_size;
     mx_status_t status = mx_thread_read_state(
         thread, MX_THREAD_STATE_REGSET0, &regs, sizeof(regs), &regset_size);
-    if (status != NO_ERROR) {
+    if (status != MX_OK) {
       if (FLAG_trace_thread_interrupter) {
         OS::PrintErr("ThreadInterrupter failed to get registers: %s\n",
                      mx_status_get_string(status));
       }
       return false;
     }
     state->pc = static_cast<uintptr_t>(regs.pc);
     state->fp = static_cast<uintptr_t>(regs.r[FPREG]);
     state->csp = static_cast<uintptr_t>(regs.sp);
     state->dsp = static_cast<uintptr_t>(regs.r[SPREG]);
@@ skipping 11 matching lines @@
 
     // Get a handle on the target thread.
     const mx_koid_t target_thread_koid = os_thread->id();
     if (FLAG_trace_thread_interrupter) {
       OS::PrintErr("ThreadInterrupter: interrupting thread with koid=%d\n",
                    target_thread_koid);
     }
     mx_handle_t target_thread_handle;
     status = mx_object_get_child(mx_process_self(), target_thread_koid,
                                  MX_RIGHT_SAME_RIGHTS, &target_thread_handle);
-    if (status != NO_ERROR) {
+    if (status != MX_OK) {
       if (FLAG_trace_thread_interrupter) {
         OS::PrintErr("ThreadInterrupter: mx_object_get_child failed: %s\n",
                      mx_status_get_string(status));
       }
       return;
     }
     if (target_thread_handle == MX_HANDLE_INVALID) {
       if (FLAG_trace_thread_interrupter) {
         OS::PrintErr(
             "ThreadInterrupter: mx_object_get_child gave an invalid "
             "thread handle!");
       }
       return;
     }
 
     // This scope suspends the thread. When we exit the scope, the thread is
     // resumed, and the thread handle is closed.
     ThreadSuspendScope tss(target_thread_handle);
     if (!tss.suspended()) {
       return;
     }
 
     // Check that the thread is suspended.
     status = PollThreadUntilSuspended(target_thread_handle);
-    if (status != NO_ERROR) {
+    if (status != MX_OK) {
       return;
     }
 
     // Grab the target thread's registers.
     InterruptedThreadState its;
     if (!GrabRegisters(target_thread_handle, &its)) {
       return;
     }
     // Currently we sample only threads that are associated
     // with an isolate. It is safe to call 'os_thread->thread()'
@@ skipping 26 matching lines @@
 
   static mx_status_t PollThreadUntilSuspended(mx_handle_t thread_handle) {
     const intptr_t kMaxPollAttempts = 10;
     intptr_t poll_tries = 0;
     while (poll_tries < kMaxPollAttempts) {
       mx_info_thread_t thread_info;
       mx_status_t status =
           mx_object_get_info(thread_handle, MX_INFO_THREAD, &thread_info,
                              sizeof(thread_info), NULL, NULL);
       poll_tries++;
-      if (status != NO_ERROR) {
+      if (status != MX_OK) {
         if (FLAG_trace_thread_interrupter) {
           OS::PrintErr("ThreadInterrupter: mx_object_get_info failed: %s\n",
                        mx_status_get_string(status));
         }
         return status;
       }
       if (thread_info.state == MX_THREAD_STATE_SUSPENDED) {
         // Success.
-        return NO_ERROR;
+        return MX_OK;
       }
       if (thread_info.state == MX_THREAD_STATE_RUNNING) {
         // Poll.
         continue;
       }
       if (FLAG_trace_thread_interrupter) {
         OS::PrintErr("ThreadInterrupter: Thread is not suspended: %s\n",
                      ThreadStateGetString(thread_info.state));
       }
-      return ERR_BAD_STATE;
+      return MX_ERR_BAD_STATE;
     }
     if (FLAG_trace_thread_interrupter) {
       OS::PrintErr("ThreadInterrupter: Exceeded max suspend poll tries\n");
     }
-    return ERR_BAD_STATE;
+    return MX_ERR_BAD_STATE;
   }
 };
 
 
 bool ThreadInterrupter::IsDebuggerAttached() {
   return false;
 }
 
 
 void ThreadInterrupter::InterruptThread(OSThread* thread) {
@@ skipping 16 matching lines @@
 
 void ThreadInterrupter::RemoveSignalHandler() {
   // Nothing to do on Fuchsia.
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart
 
 #endif  // defined(HOST_OS_FUCHSIA)