Replace Handle<> with Local in remaining gin/*

gin/object_template_builder.cc

 // Copyright 2013 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.
 
 #include "gin/object_template_builder.h"
 
 #include "gin/interceptor.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/wrapper_info.h"
 
 namespace gin {
 
 namespace {
 
 WrappableBase* WrappableFromV8(v8::Isolate* isolate,
-                               v8::Handle<v8::Value> val) {
+                               v8::Local<v8::Value> val) {
   if (!val->IsObject())
     return NULL;
-  v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(val);
+  v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(val);
   WrapperInfo* info = WrapperInfo::From(obj);
 
   // If this fails, the object is not managed by Gin.
   if (!info)
     return NULL;
 
   // We don't further validate the type of the object, but assume it's derived
   // from WrappableBase. We look up the pointer in a global registry, to make
   // sure it's actually pointed to a valid life object.
   return static_cast<WrappableBase*>(
       obj->GetAlignedPointerFromInternalField(kEncodedValueIndex));
 }
 
 NamedPropertyInterceptor* NamedInterceptorFromV8(v8::Isolate* isolate,
-                                                 v8::Handle<v8::Value> val) {
+                                                 v8::Local<v8::Value> val) {
   WrappableBase* base = WrappableFromV8(isolate, val);
   if (!base)
     return NULL;
   return PerIsolateData::From(isolate)->GetNamedPropertyInterceptor(base);
 }
 
 IndexedPropertyInterceptor* IndexedInterceptorFromV8(
     v8::Isolate* isolate,
-    v8::Handle<v8::Value> val) {
+    v8::Local<v8::Value> val) {
   WrappableBase* base = WrappableFromV8(isolate, val);
   if (!base)
     return NULL;
   return PerIsolateData::From(isolate)->GetIndexedPropertyInterceptor(base);
 }
 
 void NamedPropertyGetter(v8::Local<v8::String> property,
                          const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   NamedPropertyInterceptor* interceptor =
@@ skipping 32 matching lines @@
     return;
   info.GetReturnValue().Set(0);
 }
 
 void NamedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   NamedPropertyInterceptor* interceptor =
       NamedInterceptorFromV8(isolate, info.Holder());
   if (!interceptor)
     return;
-  info.GetReturnValue().Set(v8::Handle<v8::Array>::Cast(
+  info.GetReturnValue().Set(v8::Local<v8::Array>::Cast(
       ConvertToV8(isolate, interceptor->EnumerateNamedProperties(isolate))));
 }
 
 void IndexedPropertyGetter(uint32_t index,
                            const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   IndexedPropertyInterceptor* interceptor =
       IndexedInterceptorFromV8(isolate, info.Holder());
   if (!interceptor)
     return;
@@ skipping 12 matching lines @@
     info.GetReturnValue().Set(value);
 }
 
 void IndexedPropertyEnumerator(
     const v8::PropertyCallbackInfo<v8::Array>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   IndexedPropertyInterceptor* interceptor =
       IndexedInterceptorFromV8(isolate, info.Holder());
   if (!interceptor)
     return;
-  info.GetReturnValue().Set(v8::Handle<v8::Array>::Cast(
+  info.GetReturnValue().Set(v8::Local<v8::Array>::Cast(
       ConvertToV8(isolate, interceptor->EnumerateIndexedProperties(isolate))));
 }
 
 }  // namespace
 
 ObjectTemplateBuilder::ObjectTemplateBuilder(v8::Isolate* isolate)
     : isolate_(isolate), template_(v8::ObjectTemplate::New(isolate)) {
   template_->SetInternalFieldCount(kNumberOfInternalFields);
 }
 
@@ skipping 12 matching lines @@
 ObjectTemplateBuilder& ObjectTemplateBuilder::AddIndexedPropertyInterceptor() {
   template_->SetIndexedPropertyHandler(&IndexedPropertyGetter,
                                        &IndexedPropertySetter,
                                        NULL,
                                        NULL,
                                        &IndexedPropertyEnumerator);
   return *this;
 }
 
 ObjectTemplateBuilder& ObjectTemplateBuilder::SetImpl(
-    const base::StringPiece& name, v8::Handle<v8::Data> val) {
+    const base::StringPiece& name, v8::Local<v8::Data> val) {
   template_->Set(StringToSymbol(isolate_, name), val);
   return *this;
 }
 
 ObjectTemplateBuilder& ObjectTemplateBuilder::SetPropertyImpl(
-    const base::StringPiece& name, v8::Handle<v8::FunctionTemplate> getter,
-    v8::Handle<v8::FunctionTemplate> setter) {
+    const base::StringPiece& name, v8::Local<v8::FunctionTemplate> getter,
+    v8::Local<v8::FunctionTemplate> setter) {
   template_->SetAccessorProperty(StringToSymbol(isolate_, name), getter,
                                  setter);
   return *this;
 }
 
 v8::Local<v8::ObjectTemplate> ObjectTemplateBuilder::Build() {
   v8::Local<v8::ObjectTemplate> result = template_;
   template_.Clear();
   return result;
 }
 
 }  // namespace gin