Changed the debugger message API to receive an object instead of a JSON string

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 uint16_t* message, int length,
-                           v8::Debug::ClientData* client_data) {
+static void MessageHandler(const v8::Debug::Message& message) {
   static char print_buffer[1000];
-  Utf16ToAscii(message, length, print_buffer);
+  v8::String::Value json(message.GetJSON());
+  Utf16ToAscii(*json, json.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 161 matching lines @@
     CHECK_EQ(2, TestClientData::destructor_call_counter);
   }
   // All the client data should be destroyed when the queue is destroyed.
   CHECK_EQ(TestClientData::destructor_call_counter,
            TestClientData::destructor_call_counter);
 }
 
 
 static int handled_client_data_instances_count = 0;
 static void MessageHandlerCountingClientData(
-    const uint16_t* message,
-    int length,
-    v8::Debug::ClientData* client_data) {
-  if (client_data) {
+    const v8::Debug::Message& message) {
+  if (message.GetClientData() != NULL) {
     handled_client_data_instances_count++;
   }
 }
 
 
 // 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;
@@ skipping 55 matching lines @@
   void Run();
 };
 
 
 static v8::Handle<v8::Value> ThreadedAtBarrier1(const v8::Arguments& args) {
   threaded_debugging_barriers.barrier_1.Wait();
   return v8::Undefined();
 }
 
 
-static void ThreadedMessageHandler(const uint16_t* message, int length,
-                                   v8::Debug::ClientData* client_data) {
+static void ThreadedMessageHandler(const v8::Debug::Message& message) {
   static char print_buffer[1000];
-  Utf16ToAscii(message, length, print_buffer);
+  v8::String::Value json(message.GetJSON());
+  Utf16ToAscii(*json, json.length(), print_buffer);
   if (IsBreakEventMessage(print_buffer)) {
     threaded_debugging_barriers.barrier_2.Wait();
   }
   printf("%s\n", print_buffer);
   fflush(stdout);
 }
 
 
 void V8Thread::Run() {
   const char* source =
@@ skipping 73 matching lines @@
 };
 
 class BreakpointsDebuggerThread : public v8::internal::Thread {
  public:
   void Run();
 };
 
 
 Barriers* breakpoints_barriers;
 
-static void BreakpointsMessageHandler(const uint16_t* message,
-                                      int length,
-                                      v8::Debug::ClientData* client_data) {
+static void BreakpointsMessageHandler(const v8::Debug::Message& message) {
   static char print_buffer[1000];
-  Utf16ToAscii(message, length, print_buffer);
+  v8::String::Value json(message.GetJSON());
+  Utf16ToAscii(*json, json.length(), print_buffer);
   printf("%s\n", print_buffer);
   fflush(stdout);
 
   // Is break_template a prefix of the message?
   if (IsBreakEventMessage(print_buffer)) {
     breakpoints_barriers->semaphore_1->Signal();
   }
 }
 
 
@@ skipping 122 matching lines @@
                                     v8::Handle<v8::Object> event_data,
                                     v8::Handle<v8::Value> data) {
 }
 
 
 TEST(SetDebugEventListenerOnUninitializedVM) {
   v8::Debug::SetDebugEventListener(DummyDebugEventListener);
 }
 
 
-static void DummyMessageHandler(const uint16_t* message,
-                                int length,
-                                v8::Debug::ClientData* client_data) {
+static void DummyMessageHandler(const v8::Debug::Message& message) {
 }
 
 
 TEST(SetMessageHandlerOnUninitializedVM) {
   v8::Debug::SetMessageHandler(DummyMessageHandler);
 }
 
 
 TEST(DebugBreakOnUninitializedVM) {
   v8::Debug::DebugBreak();
@@ skipping 204 matching lines @@
   CHECK_EQ(2, break_point_hit_count);
 
   // Remove the debug event listener without clearing breakpoints again.
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded(true);
 }
 
 
 // Debugger message handler which counts the number of times it is called.
 static int message_handler_hit_count = 0;
-static void MessageHandlerHitCount(const uint16_t* message,
-                                   int length,
-                                   v8::Debug::ClientData* client_data) {
+static void MessageHandlerHitCount(const v8::Debug::Message& message) {
   message_handler_hit_count++;
 
   const int kBufferSize = 1000;
   uint16_t buffer[kBufferSize];
   const char* command_continue =
     "{\"seq\":0,"
      "\"type\":\"request\","
      "\"command\":\"continue\"}";
 
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_continue, buffer));
@@ skipping 28 matching lines @@
 
   // The message handler should not be called more.
   CHECK_EQ(0, message_handler_hit_count);
 
   CheckDebuggerUnloaded(true);
 }
 
 
 // Debugger message handler which clears the message handler while active.
 static void MessageHandlerClearingMessageHandler(
-    const uint16_t* message,
-    int length,
-    v8::Debug::ClientData* client_data) {
+    const v8::Debug::Message& message) {
   message_handler_hit_count++;
 
   // Clear debug message handler.
   v8::Debug::SetMessageHandler(NULL);
 }
 
 
 // Test clearing the debug message handler while processing a debug event.
 TEST(DebuggerClearMessageHandlerWhileActive) {
   v8::HandleScope scope;
@@ skipping 26 matching lines @@
   void Run();
 };
 
 class HostDispatchDebuggerThread : public v8::internal::Thread {
  public:
   void Run();
 };
 
 Barriers* host_dispatch_barriers;
 
-static void HostDispatchMessageHandler(const uint16_t* message,
-                                       int length,
-                                       v8::Debug::ClientData* client_data) {
+static void HostDispatchMessageHandler(const v8::Debug::Message& message) {
   static char print_buffer[1000];
-  Utf16ToAscii(message, length, print_buffer);
+  v8::String::Value json(message.GetJSON());
+  Utf16ToAscii(*json, json.length(), print_buffer);
   printf("%s\n", print_buffer);
   fflush(stdout);
 }
 
 
 static void HostDispatchDispatchHandler() {
   host_dispatch_barriers->semaphore_1->Signal();
 }
 
 
@@ skipping 311 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);
 }