Rename debug API methods.

include/v8-debug.h

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_V8_DEBUG_H_
 #define V8_V8_DEBUG_H_
 
 #include "v8.h"
 
 /**
@@ skipping 119 matching lines @@
   };
 
   /**
    * Debug event callback function.
    *
    * \param event_details object providing information about the debug event
    *
    * A EventCallback2 does not take possession of the event data,
    * and must not rely on the data persisting after the handler returns.
    */
-  typedef void (*EventCallback2)(const EventDetails& event_details);
+  typedef void (*EventCallback)(const EventDetails& event_details);
+
+  // TODO(yangguo) Deprecate this.
+  typedef EventCallback EventCallback2;
 
   /**
    * Debug message callback function.
    *
    * \param message the debug message handler message object
    *
    * A MessageHandler2 does not take possession of the message data,
    * and must not rely on the data persisting after the handler returns.
    */
-  typedef void (*MessageHandler2)(const Message& message);
+  typedef void (*MessageHandler)(const Message& message);
+
+  // TODO(yangguo) Deprecate this.
+  typedef MessageHandler MessageHandler2;
 
   /**
    * Callback function for the host to ensure debug messages are processed.
    */
   typedef void (*DebugMessageDispatchHandler)();
 
+  static bool SetDebugEventListener(EventCallback that,
+                                    Handle<Value> data = Handle<Value>());
+
+  // TODO(yangguo) Deprecate this.
   static bool SetDebugEventListener2(EventCallback2 that,
-                                     Handle<Value> data = Handle<Value>());
+                                     Handle<Value> data = Handle<Value>()) {
+    return SetDebugEventListener(that, data);
+  }
 
   // Schedule a debugger break to happen when JavaScript code is run
   // in the given isolate.
   static void DebugBreak(Isolate* isolate);
 
   // Remove scheduled debugger break in given isolate if it has not
   // happened yet.
   static void CancelDebugBreak(Isolate* isolate);
 
   // Break execution of JavaScript in the given isolate (this method
   // can be invoked from a non-VM thread) for further client command
   // execution on a VM thread. Client data is then passed in
   // EventDetails to EventCallback2 at the moment when the VM actually
   // stops.
   static void DebugBreakForCommand(Isolate* isolate, ClientData* data);
 
   // TODO(svenpanne) Remove this when Chrome is updated.
   static void DebugBreakForCommand(ClientData* data, Isolate* isolate) {
     DebugBreakForCommand(isolate, data);
   }
 
   // Message based interface. The message protocol is JSON.
-  static void SetMessageHandler2(MessageHandler2 handler);
+  static void SetMessageHandler(MessageHandler handler);
+
+  // TODO(yangguo) Deprecate this.
+  static void SetMessageHandler2(MessageHandler2 handler) {
+    SetMessageHandler(handler);
+  }
 
   static void SendCommand(Isolate* isolate,
                           const uint16_t* command, int length,
                           ClientData* client_data = NULL);
 
   /**
    * Register a callback function to be called when a debug message has been
    * received and is ready to be processed. For the debug messages to be
    * processed V8 needs to be entered, and in certain embedding scenarios this
    * callback can be used to make sure V8 is entered for the debug message to
@@ skipping 108 matching lines @@
 };
 
 
 }  // namespace v8
 
 
 #undef EXPORT
 
 
 #endif  // V8_V8_DEBUG_H_