Revert "ART: Start RuntimeCallbacks"

jdwp tests failing with:
    STDERR> dalvikvm32 E 01-18 23:14:50 12180 12198 thread-inl.h:137] holding "runtime callbacks lock" at point where thread suspension is expected

Bug: 31684920

This reverts commit 13093d455b8266338fd713b04261c58e9dc2b164.

Change-Id: I94e4154e273d006eecdd485607dcfd96392d6a00

1 files changed, 0 insertions, 201 deletions

diff --git a/runtime/runtime_callbacks_test.cc b/runtime/runtime_callbacks_test.cc
deleted file mode 100644
index 00a4062065..0000000000
--- a/runtime/runtime_callbacks_test.cc
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "runtime_callbacks.h"
-
-#include "jni.h"
-#include <memory>
-#include <string>
-
-#include "art_method-inl.h"
-#include "base/mutex.h"
-#include "mirror/class-inl.h"
-#include "common_runtime_test.h"
-#include "mem_map.h"
-#include "obj_ptr.h"
-#include "runtime.h"
-#include "ScopedLocalRef.h"
-#include "thread-inl.h"
-#include "well_known_classes.h"
-
-namespace art {
-
-class RuntimeCallbacksTest : public CommonRuntimeTest {
- protected:
-  void SetUp() OVERRIDE {
-    CommonRuntimeTest::SetUp();
-
-    WriterMutexLock mu(Thread::Current(), *Locks::runtime_callbacks_lock_);
-    AddListener();
-  }
-
-  void TearDown() OVERRIDE {
-    {
-      WriterMutexLock mu(Thread::Current(), *Locks::runtime_callbacks_lock_);
-      RemoveListener();
-    }
-
-    CommonRuntimeTest::TearDown();
-  }
-
-  virtual void AddListener() REQUIRES(Locks::runtime_callbacks_lock_) = 0;
-  virtual void RemoveListener() REQUIRES(Locks::runtime_callbacks_lock_) = 0;
-
-  void MakeExecutable(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) {
-    CHECK(klass != nullptr);
-    PointerSize pointer_size = class_linker_->GetImagePointerSize();
-    for (auto& m : klass->GetMethods(pointer_size)) {
-      if (!m.IsAbstract()) {
-        class_linker_->SetEntryPointsToInterpreter(&m);
-      }
-    }
-  }
-};
-
-class ThreadLifecycleCallbackRuntimeCallbacksTest : public RuntimeCallbacksTest {
- public:
-  static void* PthreadsCallback(void* arg ATTRIBUTE_UNUSED) {
-    // Attach.
-    Runtime* runtime = Runtime::Current();
-    CHECK(runtime->AttachCurrentThread("ThreadLifecycle test thread", true, nullptr, false));
-
-    // Detach.
-    runtime->DetachCurrentThread();
-
-    // Die...
-    return nullptr;
-  }
-
- protected:
-  void AddListener() OVERRIDE REQUIRES(Locks::runtime_callbacks_lock_) {
-    Runtime::Current()->GetRuntimeCallbacks().AddThreadLifecycleCallback(&cb_);
-  }
-  void RemoveListener() OVERRIDE REQUIRES(Locks::runtime_callbacks_lock_) {
-    Runtime::Current()->GetRuntimeCallbacks().RemoveThreadLifecycleCallback(&cb_);
-  }
-
-  enum CallbackState {
-    kBase,
-    kStarted,
-    kDied,
-    kWrongStart,
-    kWrongDeath,
-  };
-
-  struct Callback : public ThreadLifecycleCallback {
-    void ThreadStart(Thread* self) OVERRIDE {
-      if (state == CallbackState::kBase) {
-        state = CallbackState::kStarted;
-        stored_self = self;
-      } else {
-        state = CallbackState::kWrongStart;
-      }
-    }
-
-    void ThreadDeath(Thread* self) OVERRIDE {
-      if (state == CallbackState::kStarted && self == stored_self) {
-        state = CallbackState::kDied;
-      } else {
-        state = CallbackState::kWrongDeath;
-      }
-    }
-
-    Thread* stored_self;
-    CallbackState state = CallbackState::kBase;
-  };
-
-  Callback cb_;
-};
-
-
-TEST_F(ThreadLifecycleCallbackRuntimeCallbacksTest, ThreadLifecycleCallbackJava) {
-  Thread* self = Thread::Current();
-
-  self->TransitionFromSuspendedToRunnable();
-  bool started = runtime_->Start();
-  ASSERT_TRUE(started);
-
-  cb_.state = CallbackState::kBase;  // Ignore main thread attach.
-
-  {
-    ScopedObjectAccess soa(self);
-    MakeExecutable(soa.Decode<mirror::Class>(WellKnownClasses::java_lang_Thread));
-  }
-
-  JNIEnv* env = self->GetJniEnv();
-
-  ScopedLocalRef<jobject> thread_name(env,
-                                      env->NewStringUTF("ThreadLifecycleCallback test thread"));
-  ASSERT_TRUE(thread_name.get() != nullptr);
-
-  ScopedLocalRef<jobject> thread(env, env->AllocObject(WellKnownClasses::java_lang_Thread));
-  ASSERT_TRUE(thread.get() != nullptr);
-
-  env->CallNonvirtualVoidMethod(thread.get(),
-                                WellKnownClasses::java_lang_Thread,
-                                WellKnownClasses::java_lang_Thread_init,
-                                runtime_->GetMainThreadGroup(),
-                                thread_name.get(),
-                                kMinThreadPriority,
-                                JNI_FALSE);
-  ASSERT_FALSE(env->ExceptionCheck());
-
-  jmethodID start_id = env->GetMethodID(WellKnownClasses::java_lang_Thread, "start", "()V");
-  ASSERT_TRUE(start_id != nullptr);
-
-  env->CallVoidMethod(thread.get(), start_id);
-  ASSERT_FALSE(env->ExceptionCheck());
-
-  jmethodID join_id = env->GetMethodID(WellKnownClasses::java_lang_Thread, "join", "()V");
-  ASSERT_TRUE(join_id != nullptr);
-
-  env->CallVoidMethod(thread.get(), join_id);
-  ASSERT_FALSE(env->ExceptionCheck());
-
-  EXPECT_TRUE(cb_.state == CallbackState::kDied) << static_cast<int>(cb_.state);
-}
-
-TEST_F(ThreadLifecycleCallbackRuntimeCallbacksTest, ThreadLifecycleCallbackAttach) {
-  std::string error_msg;
-  std::unique_ptr<MemMap> stack(MemMap::MapAnonymous("ThreadLifecycleCallback Thread",
-                                                     nullptr,
-                                                     128 * kPageSize,  // Just some small stack.
-                                                     PROT_READ | PROT_WRITE,
-                                                     false,
-                                                     false,
-                                                     &error_msg));
-  ASSERT_FALSE(stack == nullptr) << error_msg;
-
-  const char* reason = "ThreadLifecycleCallback test thread";
-  pthread_attr_t attr;
-  CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), reason);
-  CHECK_PTHREAD_CALL(pthread_attr_setstack, (&attr, stack->Begin(), stack->Size()), reason);
-  pthread_t pthread;
-  CHECK_PTHREAD_CALL(pthread_create,
-                     (&pthread,
-                         &attr,
-                         &ThreadLifecycleCallbackRuntimeCallbacksTest::PthreadsCallback,
-                         this),
-                         reason);
-  CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), reason);
-
-  CHECK_PTHREAD_CALL(pthread_join, (pthread, nullptr), "ThreadLifecycleCallback test shutdown");
-
-  // Detach is not a ThreadDeath event, so we expect to be in state Started.
-  EXPECT_TRUE(cb_.state == CallbackState::kStarted) << static_cast<int>(cb_.state);
-}
-
-}  // namespace art