Create a transition API for the debug message handler

include/v8-debug.h

 // Copyright 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 144 matching lines @@
                                 Handle<Object> exec_state,
                                 Handle<Object> event_data,
                                 Handle<Value> data);
 
 
   /**
    * Debug message callback function.
    *
    * \param message the debug message handler message object
    * \param length length of the message
-   * \param data the data value passed when registering the message handler
+   * \param client_data the data value passed when registering the message handler
 
    * A MessageHandler does not take posession of the message string,
    * and must not rely on the data persisting after the handler returns.
+   *
+   * This message handler is deprecated. Use MessageHandler2 instead.
    */
-  typedef void (*MessageHandler)(const Message& message);
+  typedef void (*MessageHandler)(const uint16_t* message, int length,
+                                 ClientData* client_data);
+
+  /**
+   * Debug message callback function.
+   *
+   * \param message the debug message handler message object
+
+   * A MessageHandler does not take posession of the message data,
+   * and must not rely on the data persisting after the handler returns.
+   */
+  typedef void (*MessageHandler2)(const Message& message);
 
   /**
    * Debug host dispatch callback function.
    */
   typedef void (*HostDispatchHandler)();
 
   // Set a C debug event listener.
   static bool SetDebugEventListener(EventCallback that,
                                     Handle<Value> data = Handle<Value>());
 
   // Set a JavaScript debug event listener.
   static bool SetDebugEventListener(v8::Handle<v8::Object> that,
                                     Handle<Value> data = Handle<Value>());
 
   // Break execution of JavaScript.
   static void DebugBreak();
 
   // Message based interface. The message protocol is JSON. NOTE the message
   // handler thread is not supported any more parameter must be false.
   static void SetMessageHandler(MessageHandler handler,
                                 bool message_handler_thread = false);
+  static void SetMessageHandler2(MessageHandler2 handler);

[yurys, 2009/04/29 12:36:08]

When all clients are switched to the new message handler we will need to remove
the old one and rename SetMessageHandler2 to SetMessageHandler which will break
the code anyway. Consider switching to the new API without this intermediate
step.

[Søren Thygesen Gjesse, 2009/04/29 13:24:15]

I agree that this is not optimal, but we need to keep the Webkit (V8-Latest)
builder happy so that we can catch any regressions before pushing to trunk. This
API incompatibility is actually such a regression.

When we push to trunk with the rename from MessageHandler2 -> MessageHandler the
DEPS roll and the client changes in Chromium can be done as a single commit.

   static void SendCommand(const uint16_t* command, int length,
                           ClientData* client_data = NULL);
 
   // Dispatch interface.
   static void SetHostDispatchHandler(HostDispatchHandler handler,
                                      int period = 100);
 
  /**
   * Run a JavaScript function in the debugger.
   * \param fun the function to call
@@ skipping 24 matching lines @@
 };
 
 
 }  // namespace v8
 
 
 #undef EXPORT
 
 
 #endif  // V8_DEBUG_H_