Replace Handle<> with Local in remaining gin/*

gin/function_template.h

 // Copyright 2014 The Chromium 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 GIN_FUNCTION_TEMPLATE_H_
 #define GIN_FUNCTION_TEMPLATE_H_
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "gin/arguments.h"
@@ skipping 26 matching lines @@
 
 
 // CallbackHolder and CallbackHolderBase are used to pass a base::Callback from
 // CreateFunctionTemplate through v8 (via v8::FunctionTemplate) to
 // DispatchToCallback, where it is invoked.
 
 // This simple base class is used so that we can share a single object template
 // among every CallbackHolder instance.
 class GIN_EXPORT CallbackHolderBase {
  public:
-  v8::Handle<v8::External> GetHandle(v8::Isolate* isolate);
+  v8::Local<v8::External> GetHandle(v8::Isolate* isolate);
 
  protected:
   explicit CallbackHolderBase(v8::Isolate* isolate);
   virtual ~CallbackHolderBase();
 
  private:
   static void FirstWeakCallback(
       const v8::WeakCallbackInfo<CallbackHolderBase>& data);
   static void SecondWeakCallback(
       const v8::WeakCallbackInfo<CallbackHolderBase>& data);
@@ skipping 135 matching lines @@
 // DispatchToCallback converts all the JavaScript arguments to C++ types and
 // invokes the base::Callback.
 template <typename Sig>
 struct Dispatcher {};
 
 template <typename ReturnType, typename... ArgTypes>
 struct Dispatcher<ReturnType(ArgTypes...)> {
   static void DispatchToCallback(
       const v8::FunctionCallbackInfo<v8::Value>& info) {
     Arguments args(info);
-    v8::Handle<v8::External> v8_holder;
+    v8::Local<v8::External> v8_holder;
     CHECK(args.GetData(&v8_holder));
     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
         v8_holder->Value());
 
     typedef CallbackHolder<ReturnType(ArgTypes...)> HolderT;
     HolderT* holder = static_cast<HolderT*>(holder_base);
 
     using Indices = typename IndicesGenerator<sizeof...(ArgTypes)>::type;
     Invoker<Indices, ArgTypes...> invoker(&args, holder->flags);
     if (invoker.IsOK())
@@ skipping 16 matching lines @@
 template<typename Sig>
 v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
     v8::Isolate* isolate, const base::Callback<Sig> callback,
     int callback_flags = 0) {
   typedef internal::CallbackHolder<Sig> HolderT;
   HolderT* holder = new HolderT(isolate, callback, callback_flags);
 
   return v8::FunctionTemplate::New(
       isolate,
       &internal::Dispatcher<Sig>::DispatchToCallback,
-      ConvertToV8<v8::Handle<v8::External> >(isolate,
+      ConvertToV8<v8::Local<v8::External> >(isolate,
                                              holder->GetHandle(isolate)));
 }
 
 // CreateFunctionHandler installs a CallAsFunction handler on the given
 // object template that forwards to a provided C++ function or base::Callback.
 template<typename Sig>
 void CreateFunctionHandler(v8::Isolate* isolate,
                            v8::Local<v8::ObjectTemplate> tmpl,
                            const base::Callback<Sig> callback,
                            int callback_flags = 0) {
   typedef internal::CallbackHolder<Sig> HolderT;
   HolderT* holder = new HolderT(isolate, callback, callback_flags);
   tmpl->SetCallAsFunctionHandler(&internal::Dispatcher<Sig>::DispatchToCallback,
-                                 ConvertToV8<v8::Handle<v8::External> >(
+                                 ConvertToV8<v8::Local<v8::External> >(
                                      isolate, holder->GetHandle(isolate)));
 }
 
 }  // namespace gin
 
 #endif  // GIN_FUNCTION_TEMPLATE_H_