Create a transition API for the debug message handler

test/cctest/test-debug.cc

 // Copyright 2007-2008 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 3409 matching lines @@
  */
 Barriers message_queue_barriers;
 
 // This is the debugger thread, that executes no v8 calls except
 // placing JSON debugger commands in the queue.
 class MessageQueueDebuggerThread : public v8::internal::Thread {
  public:
   void Run();
 };
 
-static void MessageHandler(const v8::Debug::Message& message) {
+static void MessageHandler(const uint16_t* message, int length,
+                           v8::Debug::ClientData* client_data) {
   static char print_buffer[1000];
-  v8::String::Value json(message.GetJSON());
-  Utf16ToAscii(*json, json.length(), print_buffer);
+  Utf16ToAscii(message, length, print_buffer);
   if (IsBreakEventMessage(print_buffer)) {
     // Lets test script wait until break occurs to send commands.
     // Signals when a break is reported.
     message_queue_barriers.semaphore_2->Signal();
   }
 
   // Allow message handler to block on a semaphore, to test queueing of
   // messages while blocked.
   message_queue_barriers.semaphore_1->Wait();
   printf("%s\n", print_buffer);
@@ skipping 175 matching lines @@
 }
 
 
 // Tests that all client data passed to the debugger are sent to the handler.
 TEST(SendClientDataToHandler) {
   // Create a V8 environment
   v8::HandleScope scope;
   DebugLocalContext env;
   TestClientData::ResetCounters();
   handled_client_data_instances_count = 0;
-  v8::Debug::SetMessageHandler(MessageHandlerCountingClientData);
+  v8::Debug::SetMessageHandler2(MessageHandlerCountingClientData);
   const char* source_1 = "a = 3; b = 4; c = new Object(); c.d = 5;";
   const int kBufferSize = 1000;
   uint16_t buffer[kBufferSize];
   const char* command_1 =
       "{\"seq\":117,"
        "\"type\":\"request\","
        "\"command\":\"evaluate\","
        "\"arguments\":{\"expression\":\"1+2\"}}";
   const char* command_2 =
     "{\"seq\":118,"
@@ skipping 76 matching lines @@
       "      ThreadedAtBarrier1();\n"
       "    }\n"
       "    x = x + 1;\n"
       "  }\n"
       "}\n"
       "\n"
       "foo();\n";
 
   v8::HandleScope scope;
   DebugLocalContext env;
-  v8::Debug::SetMessageHandler(&ThreadedMessageHandler);
+  v8::Debug::SetMessageHandler2(&ThreadedMessageHandler);
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
   global_template->Set(v8::String::New("ThreadedAtBarrier1"),
                        v8::FunctionTemplate::New(ThreadedAtBarrier1));
   v8::Handle<v8::Context> context = v8::Context::New(NULL, global_template);
   v8::Context::Scope context_scope(context);
 
   CompileRun(source);
 }
 
 void DebuggerThread::Run() {
@@ skipping 79 matching lines @@
     "  var z = 3;"
     "  x += 100;\n"
     "  return x;\n"
     "}\n"
     "\n";
   const char* source_2 = "cat(17);\n"
     "cat(19);\n";
 
   v8::HandleScope scope;
   DebugLocalContext env;
-  v8::Debug::SetMessageHandler(&BreakpointsMessageHandler);
+  v8::Debug::SetMessageHandler2(&BreakpointsMessageHandler);
 
   CompileRun(source_1);
   breakpoints_barriers->barrier_1.Wait();
   breakpoints_barriers->barrier_2.Wait();
   CompileRun(source_2);
 }
 
 
 void BreakpointsDebuggerThread::Run() {
   const int kBufSize = 1000;
@@ skipping 93 matching lines @@
 TEST(SetDebugEventListenerOnUninitializedVM) {
   v8::Debug::SetDebugEventListener(DummyDebugEventListener);
 }
 
 
 static void DummyMessageHandler(const v8::Debug::Message& message) {
 }
 
 
 TEST(SetMessageHandlerOnUninitializedVM) {
-  v8::Debug::SetMessageHandler(DummyMessageHandler);
+  v8::Debug::SetMessageHandler2(DummyMessageHandler);
 }
 
 
 TEST(DebugBreakOnUninitializedVM) {
   v8::Debug::DebugBreak();
 }
 
 
 TEST(SendCommandToUninitializedVM) {
   const char* dummy_command = "{}";
@@ skipping 222 matching lines @@
 
 // Test clearing the debug message handler.
 TEST(DebuggerClearMessageHandler) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Check debugger is unloaded before it is used.
   CheckDebuggerUnloaded();
 
   // Set a debug message handler.
-  v8::Debug::SetMessageHandler(MessageHandlerHitCount);
+  v8::Debug::SetMessageHandler2(MessageHandlerHitCount);
 
   // Run code to throw a unhandled exception. This should end up in the message
   // handler.
   CompileRun("throw 1");
 
   // The message handler should be called.
   CHECK_GT(message_handler_hit_count, 0);
 
   // Clear debug message handler.
   message_handler_hit_count = 0;
@@ skipping 22 matching lines @@
 
 // Test clearing the debug message handler while processing a debug event.
 TEST(DebuggerClearMessageHandlerWhileActive) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Check debugger is unloaded before it is used.
   CheckDebuggerUnloaded();
 
   // Set a debug message handler.
-  v8::Debug::SetMessageHandler(MessageHandlerClearingMessageHandler);
+  v8::Debug::SetMessageHandler2(MessageHandlerClearingMessageHandler);
 
   // Run code to throw a unhandled exception. This should end up in the message
   // handler.
   CompileRun("throw 1");
 
   // The message handler should be called.
   CHECK_EQ(1, message_handler_hit_count);
 
   CheckDebuggerUnloaded(true);
 }
@@ skipping 39 matching lines @@
     "  y_global = 5;\n"
     "  return x;\n"
     "}\n"
     "\n";
   const char* source_2 = "cat(17);\n";
 
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Setup message and host dispatch handlers.
-  v8::Debug::SetMessageHandler(HostDispatchMessageHandler);
+  v8::Debug::SetMessageHandler2(HostDispatchMessageHandler);
   v8::Debug::SetHostDispatchHandler(HostDispatchDispatchHandler, 10 /* ms */);
 
   CompileRun(source_1);
   host_dispatch_barriers->barrier_1.Wait();
   host_dispatch_barriers->barrier_2.Wait();
   CompileRun(source_2);
 }
 
 
 void HostDispatchDebuggerThread::Run() {
@@ skipping 284 matching lines @@
   v8::ScriptOrigin origin2 = v8::ScriptOrigin(v8::String::New("new name"));
   v8::Handle<v8::Script> script2 = v8::Script::Compile(script, &origin2);
   script2->Run();
   script2->SetData(data_obj);
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
   CHECK_EQ("new name", last_script_name_hit);
   CHECK_EQ("abc 123", last_script_data_hit);
 }