Completely remove InterruptableThreadState and Fix ThreadRegistry leak

runtime/vm/thread_interrupter.cc

 // Copyright (c) 2013, 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 "vm/thread_interrupter.h"
 
 #include "vm/flags.h"
 #include "vm/lockers.h"
 #include "vm/os.h"
 #include "vm/simulator.h"
@@ skipping 130 matching lines @@
     MonitorLocker ml(monitor_);
     if (!InDeepSleep()) {
       // No need to notify, regularly waking up.
       return;
     }
     // Notify the interrupter to wake it from its deep sleep.
     ml.Notify();
   }
 }
 
-// Register the currently running thread for interrupts. If the current thread
-// is already registered, callback and data will be updated.
-InterruptableThreadState* ThreadInterrupter::Register(
-    ThreadInterruptCallback callback, void* data) {
-  if (shutdown_) {
-    return NULL;
-  }
-  ASSERT(initialized_);
-  InterruptableThreadState* state = _EnsureThreadStateCreated();
-  // Set callback and data.
-  UpdateStateObject(callback, data);
-  return state;
-}
-
-
-// Unregister the currently running thread for interrupts.
-void ThreadInterrupter::Unregister() {
-  if (shutdown_) {
-    return;
-  }
-  ASSERT(initialized_);
-  _EnsureThreadStateCreated();
-  // Clear callback and data.
-  UpdateStateObject(NULL, NULL);
-}
-
-
-InterruptableThreadState* ThreadInterrupter::_EnsureThreadStateCreated() {
-  InterruptableThreadState* state = CurrentThreadState();
-  if (state == NULL) {
-    // Create thread state object lazily.
-    ThreadId current_thread = OSThread::GetCurrentThreadId();
-    if (FLAG_trace_thread_interrupter) {
-      intptr_t tid = OSThread::ThreadIdToIntPtr(current_thread);
-      OS::Print("ThreadInterrupter Tracking %p\n",
-                reinterpret_cast<void*>(tid));
-    }
-    // Note: We currently do not free a thread's InterruptableThreadState.
-    state = new InterruptableThreadState();
-    ASSERT(state != NULL);
-    state->callback = NULL;
-    state->data = NULL;
-    state->id = current_thread;
-    SetCurrentThreadState(state);
-  }
-  return state;
-}
-
-
-void ThreadInterrupter::UpdateStateObject(ThreadInterruptCallback callback,
-                                          void* data) {
-  InterruptableThreadState* state = CurrentThreadState();
-  ThreadId current_thread = OSThread::GetCurrentThreadId();
-  ASSERT(state != NULL);
-  ASSERT(OSThread::Compare(state->id, OSThread::GetCurrentThreadId()));
-  SetCurrentThreadState(NULL);
-  // It is now safe to modify the state object. If an interrupt occurs,
-  // the current thread state will be NULL.
-  state->callback = callback;
-  state->data = data;
-  SetCurrentThreadState(state);
-  if (FLAG_trace_thread_interrupter) {
-    intptr_t tid = OSThread::ThreadIdToIntPtr(current_thread);
-    if (callback == NULL) {
-      OS::Print("ThreadInterrupter Cleared %p\n", reinterpret_cast<void*>(tid));
-    } else {
-      OS::Print("ThreadInterrupter Updated %p\n", reinterpret_cast<void*>(tid));
-    }
-  }
-}
-
-
-InterruptableThreadState* ThreadInterrupter::GetCurrentThreadState() {
-  return _EnsureThreadStateCreated();
-}
-
-
-InterruptableThreadState* ThreadInterrupter::CurrentThreadState() {
-  Thread* thread = Thread::Current();
-  return (thread == NULL) ? NULL : thread->thread_state();
-}
-
-
-void ThreadInterrupter::SetCurrentThreadState(InterruptableThreadState* state) {
-  Thread::Current()->set_thread_state(state);
-}
-
 
 void ThreadInterruptNoOp(const InterruptedThreadState& state, void* data) {
   // NoOp.
 }
 
 
 class ThreadInterrupterVisitIsolates : public IsolateVisitor {
  public:
   ThreadInterrupterVisitIsolates() {
     profiled_thread_count_ = 0;
@@ skipping 65 matching lines @@
   }
   {
     // Signal to main thread we are exiting.
     MonitorLocker shutdown_ml(monitor_);
     thread_running_ = false;
     shutdown_ml.Notify();
   }
 }
 
 }  // namespace dart