Make v8::Handle as "deprecated soon"

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 42 matching lines @@
      * Indicate whether this is a response to a continue command which will
      * start the VM running after this is processed.
      */
     virtual bool WillStartRunning() const = 0;
 
     /**
      * Access to execution state and event data. Don't store these cross
      * callbacks as their content becomes invalid. These objects are from the
      * debugger event that started the debug message loop.
      */
-    virtual Handle<Object> GetExecutionState() const = 0;
-    virtual Handle<Object> GetEventData() const = 0;
+    virtual Local<Object> GetExecutionState() const = 0;
+    virtual Local<Object> GetEventData() const = 0;
 
     /**
      * Get the debugger protocol JSON.
      */
-    virtual Handle<String> GetJSON() const = 0;
+    virtual Local<String> GetJSON() const = 0;
 
     /**
      * Get the context active when the debug event happened. Note this is not
      * the current active context as the JavaScript part of the debugger is
      * running in its own context which is entered at this point.
      */
-    virtual Handle<Context> GetEventContext() const = 0;
+    virtual Local<Context> GetEventContext() const = 0;
 
     /**
      * Client data passed with the corresponding request if any. This is the
      * client_data data value passed into Debug::SendCommand along with the
      * request that led to the message or NULL if the message is an event. The
      * debugger takes ownership of the data and will delete it even if there is
      * no message handler.
      */
     virtual ClientData* GetClientData() const = 0;
 
@@ skipping 10 matching lines @@
    public:
     /**
      * Event type.
      */
     virtual DebugEvent GetEvent() const = 0;
 
     /**
      * Access to execution state and event data of the debug event. Don't store
      * these cross callbacks as their content becomes invalid.
      */
-    virtual Handle<Object> GetExecutionState() const = 0;
-    virtual Handle<Object> GetEventData() const = 0;
+    virtual Local<Object> GetExecutionState() const = 0;
+    virtual Local<Object> GetEventData() const = 0;
 
     /**
      * Get the context active when the debug event happened. Note this is not
      * the current active context as the JavaScript part of the debugger is
      * running in its own context which is entered at this point.
      */
-    virtual Handle<Context> GetEventContext() const = 0;
+    virtual Local<Context> GetEventContext() const = 0;
 
     /**
      * Client data passed with the corresponding callback when it was
      * registered.
      */
-    virtual Handle<Value> GetCallbackData() const = 0;
+    virtual Local<Value> GetCallbackData() const = 0;
 
     /**
      * Client data passed to DebugBreakForCommand function. The
      * debugger takes ownership of the data and will delete it even if
      * there is no message handler.
      */
     virtual ClientData* GetClientData() const = 0;
 
     virtual ~EventDetails() {}
   };
@@ skipping 17 matching lines @@
    * and must not rely on the data persisting after the handler returns.
    */
   typedef void (*MessageHandler)(const Message& message);
 
   /**
    * Callback function for the host to ensure debug messages are processed.
    */
   typedef void (*DebugMessageDispatchHandler)();
 
   static bool SetDebugEventListener(EventCallback that,
-                                    Handle<Value> data = Handle<Value>());
+                                    Local<Value> data = Local<Value>());
 
   // 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);
 
   // Check if a debugger break is scheduled in the given isolate.
@@ skipping 19 matching lines @@
   * v8::Debug::Call will return the current line of JavaScript execution.
   *
   * \code
   *   function frame_source_line(exec_state) {
   *     return exec_state.frame(0).sourceLine();
   *   }
   * \endcode
   */
   static V8_DEPRECATE_SOON(
       "Use maybe version",
-      Local<Value> Call(v8::Handle<v8::Function> fun,
-                        Handle<Value> data = Handle<Value>()));
+      Local<Value> Call(v8::Local<v8::Function> fun,
+                        Local<Value> data = Local<Value>()));
   // TODO(dcarney): data arg should be a MaybeLocal
   static MaybeLocal<Value> Call(Local<Context> context,
-                                v8::Handle<v8::Function> fun,
-                                Handle<Value> data = Handle<Value>());
+                                v8::Local<v8::Function> fun,
+                                Local<Value> data = Local<Value>());
 
   /**
    * Returns a mirror object for the given object.
    */
   static V8_DEPRECATE_SOON("Use maybe version",
-                           Local<Value> GetMirror(v8::Handle<v8::Value> obj));
+                           Local<Value> GetMirror(v8::Local<v8::Value> obj));
   static MaybeLocal<Value> GetMirror(Local<Context> context,
-                                     v8::Handle<v8::Value> obj);
+                                     v8::Local<v8::Value> obj);
 
   /**
    * Makes V8 process all pending debug messages.
    *
    * From V8 point of view all debug messages come asynchronously (e.g. from
    * remote debugger) but they all must be handled synchronously: V8 cannot
    * do 2 things at one time so normal script execution must be interrupted
    * for a while.
    *
    * Generally when message arrives V8 may be in one of 3 states:
@@ skipping 48 matching lines @@
 };
 
 
 }  // namespace v8
 
 
 #undef EXPORT
 
 
 #endif  // V8_V8_DEBUG_H_