Revert "Simplify debugger state."

test/cctest/test-debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 80 matching lines @@
   }
   inline v8::Local<v8::Context> context() { return context_; }
   inline v8::Context* operator->() { return *context_; }
   inline v8::Context* operator*() { return *context_; }
   inline v8::Isolate* GetIsolate() { return context_->GetIsolate(); }
   inline bool IsReady() { return !context_.IsEmpty(); }
   void ExposeDebug() {
     v8::internal::Isolate* isolate =
         reinterpret_cast<v8::internal::Isolate*>(context_->GetIsolate());
     v8::internal::Factory* factory = isolate->factory();
+    v8::internal::Debug* debug = isolate->debug();
     // Expose the debug context global object in the global object for testing.
-    CHECK(isolate->debug()->Load());
-    Handle<v8::internal::Context> debug_context =
-        isolate->debug()->debug_context();
-    debug_context->set_security_token(
+    debug->Load();
+    debug->debug_context()->set_security_token(
         v8::Utils::OpenHandle(*context_)->security_token());
 
     Handle<JSGlobalProxy> global(Handle<JSGlobalProxy>::cast(
         v8::Utils::OpenHandle(*context_->Global())));
     Handle<v8::internal::String> debug_string =
         factory->InternalizeOneByteString(STATIC_ASCII_VECTOR("debug"));
     v8::internal::Runtime::SetObjectProperty(isolate, global, debug_string,
-        Handle<Object>(debug_context->global_proxy(), isolate),
+        Handle<Object>(debug->debug_context()->global_proxy(), isolate),
         DONT_ENUM,
         ::v8::internal::SLOPPY).Check();
   }
 
  private:
   v8::HandleScope scope_;
   v8::Local<v8::Context> context_;
 };
 
 
@@ skipping 291 matching lines @@
           } else if (RelocInfo::IsJSReturn(rmode)) {
             CHECK(!Debug::IsDebugBreakAtReturn(it.rinfo()));
           }
         }
       }
     }
   }
 }
 
 
+void ForceUnloadDebugger() {
+  CcTest::i_isolate()->debugger()->never_unload_debugger_ = false;
+  CcTest::i_isolate()->debugger()->UnloadDebugger();
+}
+
+
 } }  // namespace v8::internal
 
 
 // Check that the debugger has been fully unloaded.
 static void CheckDebuggerUnloaded(bool check_functions = false) {
   // Let debugger to unload itself synchronously
   v8::Debug::ProcessDebugMessages();
 
   v8::internal::CheckDebuggerUnloaded(check_functions);
 }
@@ skipping 5053 matching lines @@
 
 // Function to test passing an additional parameter to a JavaScript function
 // called in the debugger. It also tests that functions called in the debugger
 // can throw exceptions.
 static void CheckDataParameter(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Handle<v8::String> data =
       v8::String::NewFromUtf8(args.GetIsolate(), "Test");
   CHECK(v8::Debug::Call(debugger_call_with_data, data)->IsString());
 
-  for (int i = 0; i < 3; i++) {
-    v8::TryCatch catcher;
-    CHECK(v8::Debug::Call(debugger_call_with_data).IsEmpty());
-    CHECK(catcher.HasCaught());
-    CHECK(catcher.Exception()->IsString());
-  }
+  CHECK(v8::Debug::Call(debugger_call_with_data).IsEmpty());
+  CHECK(v8::Debug::Call(debugger_call_with_data).IsEmpty());
+
+  v8::TryCatch catcher;
+  v8::Debug::Call(debugger_call_with_data);
+  CHECK(catcher.HasCaught());
+  CHECK(catcher.Exception()->IsString());
 }
 
 
 // Function to test using a JavaScript with closure in the debugger.
 static void CheckClosure(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(v8::Debug::Call(debugger_call_with_closure)->IsNumber());
   CHECK_EQ(3, v8::Debug::Call(debugger_call_with_closure)->Int32Value());
 }
 
 
@@ skipping 1345 matching lines @@
 
   v8::Debug::SetDebugEventListener(NULL);
   debugee_context = v8::Handle<v8::Context>();
   debugger_context = v8::Handle<v8::Context>();
   CheckDebuggerUnloaded();
 }
 
 
 TEST(DebugContextIsPreservedBetweenAccesses) {
   v8::HandleScope scope(CcTest::isolate());
-  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
   v8::Local<v8::Context> context1 = v8::Debug::GetDebugContext();
   v8::Local<v8::Context> context2 = v8::Debug::GetDebugContext();
   CHECK_EQ(*context1, *context2);
-  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 static v8::Handle<v8::Value> expected_callback_data;
 static void DebugEventContextChecker(const v8::Debug::EventDetails& details) {
   CHECK(details.GetEventContext() == expected_context);
   CHECK_EQ(expected_callback_data, details.GetCallbackData());
 }
 
 
@@ skipping 533 matching lines @@
   env->Global()->Set(v8_str("add_debug_break"), add_debug_break);
 
   CompileRun("(function loop() {"
              "  for (var j = 0; j < 1000; j++) {"
              "    for (var i = 0; i < 1000; i++) {"
              "      if (i == 999) add_debug_break();"
              "    }"
              "  }"
              "})()");
 }