Use Local instead of Handle in src/content/*

content/renderer/pepper/plugin_object.cc

 // Copyright (c) 2011 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 "content/renderer/pepper/plugin_object.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 40 matching lines @@
     ppp_class_->Deallocate(ppp_class_data_);
     instance_->RemovePluginObject(this);
   }
 }
 
 // static
 gin::WrapperInfo PluginObject::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 // static
 PluginObject* PluginObject::FromV8Object(v8::Isolate* isolate,
-                                         v8::Handle<v8::Object> v8_object) {
+                                         v8::Local<v8::Object> v8_object) {
   PluginObject* plugin_object;
   if (!v8_object.IsEmpty() &&
       gin::ConvertFromV8(isolate, v8_object, &plugin_object)) {
     return plugin_object;
   }
   return NULL;
 }
 
 // static
 PP_Var PluginObject::Create(PepperPluginInstanceImpl* instance,
@@ skipping 122 matching lines @@
   if (try_catch.ThrowException())
     return v8::Local<v8::Value>();
 
   if (has_property) {
     ScopedPPVar result_var(ScopedPPVar::PassRef(),
         ppp_class_->GetProperty(ppp_class_data_, identifier_var,
                                 try_catch.exception()));
     if (try_catch.ThrowException())
       return v8::Local<v8::Value>();
 
-    v8::Handle<v8::Value> result = try_catch.ToV8(result_var.get());
+    v8::Local<v8::Value> result = try_catch.ToV8(result_var.get());
     if (try_catch.ThrowException())
       return v8::Local<v8::Value>();
 
     return result;
   }
 
   bool has_method = identifier_var.type == PP_VARTYPE_STRING &&
                     ppp_class_->HasMethod(ppp_class_data_, identifier_var,
                                           try_catch.exception());
   if (try_catch.ThrowException())
@@ skipping 14 matching lines @@
     return;
 
   V8VarConverter var_converter(instance_->pp_instance(),
                                V8VarConverter::kAllowObjectVars);
   PepperTryCatchV8 try_catch(instance_, &var_converter, args->isolate());
   ScopedPPVar identifier_var(ScopedPPVar::PassRef(),
                              StringVar::StringToPPVar(identifier));
   ScopedPPVarArray argument_vars(args->Length());
 
   for (uint32_t i = 0; i < argument_vars.size(); ++i) {
-    v8::Handle<v8::Value> arg;
+    v8::Local<v8::Value> arg;
     if (!args->GetNext(&arg)) {
       NOTREACHED();
     }
 
     argument_vars.Set(i, try_catch.FromV8(arg));
     if (try_catch.ThrowException())
       return;
   }
 
   // For the OOP plugin case we need to grab a reference on the plugin module
   // object to ensure that it is not destroyed courtesy an incoming
   // ExecuteScript call which destroys the plugin module and in turn the
   // dispatcher.
   scoped_refptr<PluginModule> ref(instance_->module());
 
   ScopedPPVar result_var(ScopedPPVar::PassRef(),
       ppp_class_->Call(ppp_class_data_, identifier_var.get(),
                        argument_vars.size(), argument_vars.get(),
                        try_catch.exception()));
   if (try_catch.ThrowException())
     return;
 
-  v8::Handle<v8::Value> result = try_catch.ToV8(result_var.get());
+  v8::Local<v8::Value> result = try_catch.ToV8(result_var.get());
   if (try_catch.ThrowException())
     return;
 
   args->Return(result);
 }
 
 v8::Local<v8::FunctionTemplate> PluginObject::GetFunctionTemplate(
     v8::Isolate* isolate,
     const std::string& name) {
   v8::Local<v8::FunctionTemplate> function_template = template_cache_.Get(name);
   if (!function_template.IsEmpty())
     return function_template;
   function_template =
       gin::CreateFunctionTemplate(
           isolate, base::Bind(&PluginObject::Call, weak_factory_.GetWeakPtr(),
                               name));
   template_cache_.Set(name, function_template);
   return function_template;
 }
 
 }  // namespace content