Replace Handle<> with Local in remaining gin/*

Handle is an alias for Local

BUG=424445

Review URL: https://codereview.chromium.org/1112923003

Cr-Commit-Position: refs/heads/master@{#327672}

gin/arguments.cc

@@ -26,13 +26,13 @@ Arguments::Arguments(const v8::FunctionCallbackInfo<v8::Value>& info)
 Arguments::~Arguments() {
 }
 
-v8::Handle<v8::Value> Arguments::PeekNext() const {
+v8::Local<v8::Value> Arguments::PeekNext() const {
   if (next_ >= info_->Length())
-    return v8::Handle<v8::Value>();
+    return v8::Local<v8::Value>();
   return (*info_)[next_];
 }
 
-std::string V8TypeAsString(v8::Handle<v8::Value> value) {
+std::string V8TypeAsString(v8::Local<v8::Value> value) {
   if (value.IsEmpty())
     return "<empty handle>";
   if (value->IsUndefined())

gin/arguments.h

@@ -36,7 +36,7 @@ class GIN_EXPORT Arguments {
       insufficient_arguments_ = true;
       return false;
     }
-    v8::Handle<v8::Value> val = (*info_)[next_++];
+    v8::Local<v8::Value> val = (*info_)[next_++];
     return ConvertFromV8(isolate_, val, out);
   }
 
@@ -49,7 +49,7 @@ class GIN_EXPORT Arguments {
     int remaining = info_->Length() - next_;
     out->resize(remaining);
     for (int i = 0; i < remaining; ++i) {
-      v8::Handle<v8::Value> val = (*info_)[next_++];
+      v8::Local<v8::Value> val = (*info_)[next_++];
       if (!ConvertFromV8(isolate_, val, &out->at(i)))
         return false;
     }
@@ -72,7 +72,7 @@ class GIN_EXPORT Arguments {
     info_->GetReturnValue().Set(ConvertToV8(isolate_, val));
   }
 
-  v8::Handle<v8::Value> PeekNext() const;
+  v8::Local<v8::Value> PeekNext() const;
 
   void ThrowError() const;
   void ThrowTypeError(const std::string& message) const;

gin/array_buffer.cc

@@ -62,7 +62,7 @@ ArrayBufferAllocator* ArrayBufferAllocator::SharedInstance() {
 class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
  public:
   static scoped_refptr<Private> From(v8::Isolate* isolate,
-                                     v8::Handle<v8::ArrayBuffer> array);
+                                     v8::Local<v8::ArrayBuffer> array);
 
   void* buffer() const { return buffer_; }
   size_t length() const { return length_; }
@@ -70,7 +70,7 @@ class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
  private:
   friend class base::RefCounted<Private>;
 
-  Private(v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array);
+  Private(v8::Isolate* isolate, v8::Local<v8::ArrayBuffer> array);
   ~Private();
 
   static void FirstWeakCallback(const v8::WeakCallbackInfo<Private>& data);
@@ -84,9 +84,9 @@ class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
 };
 
 scoped_refptr<ArrayBuffer::Private> ArrayBuffer::Private::From(
-    v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array) {
+    v8::Isolate* isolate, v8::Local<v8::ArrayBuffer> array) {
   if (array->IsExternal()) {
-    CHECK_EQ(WrapperInfo::From(v8::Handle<v8::Object>::Cast(array)),
+    CHECK_EQ(WrapperInfo::From(v8::Local<v8::Object>::Cast(array)),
              &g_array_buffer_wrapper_info)
         << "Cannot mix blink and gin ArrayBuffers";
     return make_scoped_refptr(static_cast<Private*>(
@@ -96,7 +96,7 @@ scoped_refptr<ArrayBuffer::Private> ArrayBuffer::Private::From(
 }
 
 ArrayBuffer::Private::Private(v8::Isolate* isolate,
-                              v8::Handle<v8::ArrayBuffer> array)
+                              v8::Local<v8::ArrayBuffer> array)
     : array_buffer_(isolate, array), isolate_(isolate) {
   // Take ownership of the array buffer.
   CHECK(!array->IsExternal());
@@ -138,7 +138,7 @@ ArrayBuffer::ArrayBuffer()
 }
 
 ArrayBuffer::ArrayBuffer(v8::Isolate* isolate,
-                         v8::Handle<v8::ArrayBuffer> array) {
+                         v8::Local<v8::ArrayBuffer> array) {
   private_ = ArrayBuffer::Private::From(isolate, array);
   bytes_ = private_->buffer();
   num_bytes_ = private_->length();
@@ -157,11 +157,11 @@ ArrayBuffer& ArrayBuffer::operator=(const ArrayBuffer& other) {
 // Converter<ArrayBuffer> -----------------------------------------------------
 
 bool Converter<ArrayBuffer>::FromV8(v8::Isolate* isolate,
-                                    v8::Handle<v8::Value> val,
+                                    v8::Local<v8::Value> val,
                                     ArrayBuffer* out) {
   if (!val->IsArrayBuffer())
     return false;
-  *out = ArrayBuffer(isolate, v8::Handle<v8::ArrayBuffer>::Cast(val));
+  *out = ArrayBuffer(isolate, v8::Local<v8::ArrayBuffer>::Cast(val));
   return true;
 }
 
@@ -173,7 +173,7 @@ ArrayBufferView::ArrayBufferView()
 }
 
 ArrayBufferView::ArrayBufferView(v8::Isolate* isolate,
-                                 v8::Handle<v8::ArrayBufferView> view)
+                                 v8::Local<v8::ArrayBufferView> view)
     : array_buffer_(isolate, view->Buffer()),
       offset_(view->ByteOffset()),
       num_bytes_(view->ByteLength()) {
@@ -193,11 +193,11 @@ ArrayBufferView& ArrayBufferView::operator=(const ArrayBufferView& other) {
 // Converter<ArrayBufferView> -------------------------------------------------
 
 bool Converter<ArrayBufferView>::FromV8(v8::Isolate* isolate,
-                                        v8::Handle<v8::Value> val,
+                                        v8::Local<v8::Value> val,
                                         ArrayBufferView* out) {
   if (!val->IsArrayBufferView())
     return false;
-  *out = ArrayBufferView(isolate, v8::Handle<v8::ArrayBufferView>::Cast(val));
+  *out = ArrayBufferView(isolate, v8::Local<v8::ArrayBufferView>::Cast(val));
   return true;
 }
 

gin/array_buffer.h

@@ -26,7 +26,7 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
 class GIN_EXPORT ArrayBuffer {
  public:
   ArrayBuffer();
-  ArrayBuffer(v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> buffer);
+  ArrayBuffer(v8::Isolate* isolate, v8::Local<v8::ArrayBuffer> buffer);
   ~ArrayBuffer();
   ArrayBuffer& operator=(const ArrayBuffer& other);
 
@@ -45,14 +45,14 @@ class GIN_EXPORT ArrayBuffer {
 
 template<>
 struct GIN_EXPORT Converter<ArrayBuffer> {
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      ArrayBuffer* out);
 };
 
 class GIN_EXPORT ArrayBufferView {
  public:
   ArrayBufferView();
-  ArrayBufferView(v8::Isolate* isolate, v8::Handle<v8::ArrayBufferView> view);
+  ArrayBufferView(v8::Isolate* isolate, v8::Local<v8::ArrayBufferView> view);
   ~ArrayBufferView();
   ArrayBufferView& operator=(const ArrayBufferView& other);
 
@@ -71,7 +71,7 @@ class GIN_EXPORT ArrayBufferView {
 
 template<>
 struct GIN_EXPORT Converter<ArrayBufferView> {
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      ArrayBufferView* out);
 };
 

gin/context_holder.cc

@@ -18,7 +18,7 @@ ContextHolder::~ContextHolder() {
   data_.reset();
 }
 
-void ContextHolder::SetContext(v8::Handle<v8::Context> context) {
+void ContextHolder::SetContext(v8::Local<v8::Context> context) {
   DCHECK(context_.IsEmpty());
   context_.Reset(isolate_, context);
   data_.reset(new PerContextData(this, context));

gin/converter.cc

@@ -166,7 +166,7 @@ Handle<Value> Converter<Handle<External> >::ToV8(Isolate* isolate,
 }
 
 bool Converter<Handle<External> >::FromV8(Isolate* isolate,
-                                          v8::Handle<Value> val,
+                                          v8::Local<Value> val,
                                           Handle<External>* out) {
   if (!val->IsExternal())
     return false;
@@ -185,7 +185,7 @@ bool Converter<Handle<Value> >::FromV8(Isolate* isolate, Handle<Value> val,
   return true;
 }
 
-v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
+v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
                                       const base::StringPiece& val) {
   return String::NewFromUtf8(isolate,
                              val.data(),
@@ -193,7 +193,7 @@ v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
                              static_cast<uint32_t>(val.length()));
 }
 
-std::string V8ToString(v8::Handle<v8::Value> value) {
+std::string V8ToString(v8::Local<v8::Value> value) {
   if (value.IsEmpty())
     return std::string();
   std::string result;

gin/converter.h

@@ -19,133 +19,133 @@ struct Converter {};
 
 template<>
 struct GIN_EXPORT Converter<bool> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     bool val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      bool* out);
 };
 
 template<>
 struct GIN_EXPORT Converter<int32_t> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     int32_t val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      int32_t* out);
 };
 
 template<>
 struct GIN_EXPORT Converter<uint32_t> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     uint32_t val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      uint32_t* out);
 };
 
 template<>
 struct GIN_EXPORT Converter<int64_t> {
   // Warning: JavaScript cannot represent 64 integers precisely.
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     int64_t val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      int64_t* out);
 };
 
 template<>
 struct GIN_EXPORT Converter<uint64_t> {
   // Warning: JavaScript cannot represent 64 integers precisely.
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     uint64_t val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      uint64_t* out);
 };
 
 template<>
 struct GIN_EXPORT Converter<float> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     float val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      float* out);
 };
 
 template<>
 struct GIN_EXPORT Converter<double> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     double val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      double* out);
 };
 
 template<>
 struct GIN_EXPORT Converter<base::StringPiece> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     const base::StringPiece& val);
   // No conversion out is possible because StringPiece does not contain storage.
 };
 
 template<>
 struct GIN_EXPORT Converter<std::string> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     const std::string& val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      std::string* out);
 };
 
 template<>
-struct GIN_EXPORT Converter<v8::Handle<v8::Function> > {
+struct GIN_EXPORT Converter<v8::Local<v8::Function> > {
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     v8::Handle<v8::Function>* out);
+                     v8::Local<v8::Value> val,
+                     v8::Local<v8::Function>* out);
 };
 
 template<>
-struct GIN_EXPORT Converter<v8::Handle<v8::Object> > {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    v8::Handle<v8::Object> val);
+struct GIN_EXPORT Converter<v8::Local<v8::Object> > {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                    v8::Local<v8::Object> val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     v8::Handle<v8::Object>* out);
+                     v8::Local<v8::Value> val,
+                     v8::Local<v8::Object>* out);
 };
 
 template<>
-struct GIN_EXPORT Converter<v8::Handle<v8::ArrayBuffer> > {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    v8::Handle<v8::ArrayBuffer> val);
+struct GIN_EXPORT Converter<v8::Local<v8::ArrayBuffer> > {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                    v8::Local<v8::ArrayBuffer> val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     v8::Handle<v8::ArrayBuffer>* out);
+                     v8::Local<v8::Value> val,
+                     v8::Local<v8::ArrayBuffer>* out);
 };
 
 template<>
-struct GIN_EXPORT Converter<v8::Handle<v8::External> > {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    v8::Handle<v8::External> val);
+struct GIN_EXPORT Converter<v8::Local<v8::External> > {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                    v8::Local<v8::External> val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     v8::Handle<v8::External>* out);
+                     v8::Local<v8::Value> val,
+                     v8::Local<v8::External>* out);
 };
 
 template<>
-struct GIN_EXPORT Converter<v8::Handle<v8::Value> > {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    v8::Handle<v8::Value> val);
+struct GIN_EXPORT Converter<v8::Local<v8::Value> > {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     v8::Handle<v8::Value>* out);
+                     v8::Local<v8::Value> val,
+                     v8::Local<v8::Value>* out);
 };
 
 template<typename T>
 struct Converter<std::vector<T> > {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     const std::vector<T>& val) {
-    v8::Handle<v8::Array> result(
+    v8::Local<v8::Array> result(
         v8::Array::New(isolate, static_cast<int>(val.size())));
     for (size_t i = 0; i < val.size(); ++i) {
       result->Set(static_cast<int>(i), Converter<T>::ToV8(isolate, val[i]));
@@ -154,13 +154,13 @@ struct Converter<std::vector<T> > {
   }
 
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      std::vector<T>* out) {
     if (!val->IsArray())
       return false;
 
     std::vector<T> result;
-    v8::Handle<v8::Array> array(v8::Handle<v8::Array>::Cast(val));
+    v8::Local<v8::Array> array(v8::Local<v8::Array>::Cast(val));
     uint32_t length = array->Length();
     for (uint32_t i = 0; i < length; ++i) {
       T item;
@@ -176,26 +176,26 @@ struct Converter<std::vector<T> > {
 
 // Convenience functions that deduce T.
 template<typename T>
-v8::Handle<v8::Value> ConvertToV8(v8::Isolate* isolate, T input) {
+v8::Local<v8::Value> ConvertToV8(v8::Isolate* isolate, T input) {
   return Converter<T>::ToV8(isolate, input);
 }
 
-GIN_EXPORT inline v8::Handle<v8::String> StringToV8(
+GIN_EXPORT inline v8::Local<v8::String> StringToV8(
     v8::Isolate* isolate,
     const base::StringPiece& input) {
   return ConvertToV8(isolate, input).As<v8::String>();
 }
 
-GIN_EXPORT v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
+GIN_EXPORT v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
                                                  const base::StringPiece& val);
 
 template<typename T>
-bool ConvertFromV8(v8::Isolate* isolate, v8::Handle<v8::Value> input,
+bool ConvertFromV8(v8::Isolate* isolate, v8::Local<v8::Value> input,
                    T* result) {
   return Converter<T>::FromV8(isolate, input, result);
 }
 
-GIN_EXPORT std::string V8ToString(v8::Handle<v8::Value> value);
+GIN_EXPORT std::string V8ToString(v8::Local<v8::Value> value);
 
 }  // namespace gin
 

gin/converter_unittest.cc

@@ -79,7 +79,7 @@ TEST_F(ConverterTest, Int32) {
   }
 
   struct {
-    v8::Handle<v8::Value> input;
+    v8::Local<v8::Value> input;
     bool expect_sucess;
     int expected_result;
   } test_data_from[] = {

gin/dictionary.cc

@@ -11,7 +11,7 @@ Dictionary::Dictionary(v8::Isolate* isolate)
 }
 
 Dictionary::Dictionary(v8::Isolate* isolate,
-                       v8::Handle<v8::Object> object)
+                       v8::Local<v8::Object> object)
     : isolate_(isolate),
       object_(object) {
 }
@@ -25,17 +25,17 @@ Dictionary Dictionary::CreateEmpty(v8::Isolate* isolate) {
   return dictionary;
 }
 
-v8::Handle<v8::Value> Converter<Dictionary>::ToV8(v8::Isolate* isolate,
+v8::Local<v8::Value> Converter<Dictionary>::ToV8(v8::Isolate* isolate,
                                                   Dictionary val) {
   return val.object_;
 }
 
 bool Converter<Dictionary>::FromV8(v8::Isolate* isolate,
-                                   v8::Handle<v8::Value> val,
+                                   v8::Local<v8::Value> val,
                                    Dictionary* out) {
   if (!val->IsObject())
     return false;
-  *out = Dictionary(isolate, v8::Handle<v8::Object>::Cast(val));
+  *out = Dictionary(isolate, v8::Local<v8::Object>::Cast(val));
   return true;
 }
 

gin/dictionary.h

@@ -25,14 +25,14 @@ namespace gin {
 class GIN_EXPORT Dictionary {
  public:
   explicit Dictionary(v8::Isolate* isolate);
-  Dictionary(v8::Isolate* isolate, v8::Handle<v8::Object> object);
+  Dictionary(v8::Isolate* isolate, v8::Local<v8::Object> object);
   ~Dictionary();
 
   static Dictionary CreateEmpty(v8::Isolate* isolate);
 
   template<typename T>
   bool Get(const std::string& key, T* out) {
-    v8::Handle<v8::Value> val = object_->Get(StringToV8(isolate_, key));
+    v8::Local<v8::Value> val = object_->Get(StringToV8(isolate_, key));
     return ConvertFromV8(isolate_, val, out);
   }
 
@@ -48,15 +48,15 @@ class GIN_EXPORT Dictionary {
 
   // TODO(aa): Remove this. Instead, get via FromV8(), Set(), and Get().
   v8::Isolate* isolate_;
-  v8::Handle<v8::Object> object_;
+  v8::Local<v8::Object> object_;
 };
 
 template<>
 struct GIN_EXPORT Converter<Dictionary> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     Dictionary val);
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      Dictionary* out);
 };
 

gin/function_template.cc

@@ -18,7 +18,7 @@ CallbackHolderBase::~CallbackHolderBase() {
   DCHECK(v8_ref_.IsEmpty());
 }
 
-v8::Handle<v8::External> CallbackHolderBase::GetHandle(v8::Isolate* isolate) {
+v8::Local<v8::External> CallbackHolderBase::GetHandle(v8::Isolate* isolate) {
   return v8::Local<v8::External>::New(isolate, v8_ref_);
 }
 

gin/function_template.h

@@ -44,7 +44,7 @@ struct CallbackParamTraits<const T*> {
 // 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);
@@ -200,7 +200,7 @@ 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());
@@ -237,7 +237,7 @@ v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
   return v8::FunctionTemplate::New(
       isolate,
       &internal::Dispatcher<Sig>::DispatchToCallback,
-      ConvertToV8<v8::Handle<v8::External> >(isolate,
+      ConvertToV8<v8::Local<v8::External> >(isolate,
                                              holder->GetHandle(isolate)));
 }
 
@@ -251,7 +251,7 @@ void CreateFunctionHandler(v8::Isolate* isolate,
   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)));
 }
 

gin/handle.h

@@ -18,7 +18,7 @@ class Handle {
  public:
   Handle() : object_(NULL) {}
 
-  Handle(v8::Handle<v8::Value> wrapper, T* object)
+  Handle(v8::Local<v8::Value> wrapper, T* object)
     : wrapper_(wrapper),
       object_(object) {
   }
@@ -31,21 +31,21 @@ class Handle {
   }
 
   T* operator->() const { return object_; }
-  v8::Handle<v8::Value> ToV8() const { return wrapper_; }
+  v8::Local<v8::Value> ToV8() const { return wrapper_; }
   T* get() const { return object_; }
 
  private:
-  v8::Handle<v8::Value> wrapper_;
+  v8::Local<v8::Value> wrapper_;
   T* object_;
 };
 
 template<typename T>
 struct Converter<gin::Handle<T> > {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                     const gin::Handle<T>& val) {
     return val.ToV8();
   }
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      gin::Handle<T>* out) {
     T* object = NULL;
     if (!Converter<T*>::FromV8(isolate, val, &object)) {
@@ -60,7 +60,7 @@ struct Converter<gin::Handle<T> > {
 // without having to write out the type of the object explicitly.
 template<typename T>
 gin::Handle<T> CreateHandle(v8::Isolate* isolate, T* object) {
-  v8::Handle<v8::Object> wrapper = object->GetWrapper(isolate);
+  v8::Local<v8::Object> wrapper = object->GetWrapper(isolate);
   if (wrapper.IsEmpty())
     return gin::Handle<T>();
   return gin::Handle<T>(wrapper, object);

gin/interceptor_unittest.cc

@@ -136,17 +136,17 @@ class InterceptorTest : public V8Test {
     obj->set_value(42);
     EXPECT_EQ(42, obj->value());
 
-    v8::Handle<v8::