Use Local instead of Handle in src/content/*

content/renderer/pepper/ppb_var_deprecated_impl.cc

 // Copyright (c) 2012 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/ppb_var_deprecated_impl.h"
 
 #include <limits>
 
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/message_channel.h"
@@ skipping 45 matching lines @@
     if (exception && exception->type != PP_VARTYPE_UNDEFINED)
       return false;
     if (instance_)
       return true;
     if (exception)
       *exception = ppapi::StringVar::StringToPPVar(kInvalidObjectException);
     return false;
   }
   // Lazily grab the object so that the handle is created in the current handle
   // scope.
-  v8::Handle<v8::Object> GetObject() { return object_var_->GetHandle(); }
+  v8::Local<v8::Object> GetObject() { return object_var_->GetHandle(); }
   PepperPluginInstanceImpl* instance() { return instance_; }
   V8VarConverter* converter() { return converter_.get(); }
 
  private:
   V8ObjectVar* object_var_;
   PepperPluginInstanceImpl* instance_;
   scoped_ptr<V8VarConverter> converter_;
 };
 
 bool IsValidIdentifer(PP_Var identifier, PP_Var* exception) {
   if (identifier.type == PP_VARTYPE_INT32 ||
       identifier.type == PP_VARTYPE_STRING) {
     return true;
   }
   if (exception)
     *exception = ppapi::StringVar::StringToPPVar(kInvalidIdentifierException);
   return false;
 }
 
 bool HasPropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessor accessor(var);
   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
     return false;
 
   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
                               exception);
-  v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
+  v8::Local<v8::Value> v8_name = try_catch.ToV8(name);
   if (try_catch.HasException())
     return false;
 
   bool result = accessor.GetObject()->Has(v8_name);
   if (try_catch.HasException())
     return false;
   return result;
 }
 
 bool HasMethodDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessor accessor(var);
   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
     return false;
 
   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
                               exception);
-  v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
+  v8::Local<v8::Value> v8_name = try_catch.ToV8(name);
   if (try_catch.HasException())
     return false;
 
   bool result = accessor.GetObject()->Has(v8_name) &&
       accessor.GetObject()->Get(v8_name)->IsFunction();
   if (try_catch.HasException())
     return false;
   return result;
 }
 
 PP_Var GetProperty(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessor accessor(var);
   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
     return PP_MakeUndefined();
 
   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
                               exception);
-  v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
+  v8::Local<v8::Value> v8_name = try_catch.ToV8(name);
   if (try_catch.HasException())
     return PP_MakeUndefined();
 
   ScopedPPVar result_var = try_catch.FromV8(accessor.GetObject()->Get(v8_name));
   if (try_catch.HasException())
     return PP_MakeUndefined();
 
   return result_var.Release();
 }
 
@@ skipping 31 matching lines @@
 void SetPropertyDeprecated(PP_Var var,
                            PP_Var name,
                            PP_Var value,
                            PP_Var* exception) {
   ObjectAccessor accessor(var);
   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
     return;
 
   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
                               exception);
-  v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
-  v8::Handle<v8::Value> v8_value = try_catch.ToV8(value);
+  v8::Local<v8::Value> v8_name = try_catch.ToV8(name);
+  v8::Local<v8::Value> v8_value = try_catch.ToV8(value);
 
   if (try_catch.HasException())
     return;
 
   accessor.GetObject()->Set(v8_name, v8_value);
   try_catch.HasException();  // Ensure an exception gets set if one occured.
 }
 
 void DeletePropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessor accessor(var);
   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
     return;
 
   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
                               exception);
-  v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
+  v8::Local<v8::Value> v8_name = try_catch.ToV8(name);
 
   if (try_catch.HasException())
     return;
 
   accessor.GetObject()->Delete(v8_name);
   try_catch.HasException();  // Ensure an exception gets set if one occured.
 }
 
 PP_Var CallDeprecatedInternal(PP_Var var,
                               PP_Var method_name,
                               uint32_t argc,
                               PP_Var* argv,
                               PP_Var* exception) {
   ObjectAccessor accessor(var);
   if (!accessor.IsValid(exception))
     return PP_MakeUndefined();
 
   // If the method name is undefined, set it to the empty string to trigger
   // calling |var| as a function.
   ScopedPPVar scoped_name(method_name);
   if (method_name.type == PP_VARTYPE_UNDEFINED) {
     scoped_name = ScopedPPVar(ScopedPPVar::PassRef(),
                                 StringVar::StringToPPVar(""));
   }
 
   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
                               exception);
-  v8::Handle<v8::Value> v8_method_name = try_catch.ToV8(scoped_name.get());
+  v8::Local<v8::Value> v8_method_name = try_catch.ToV8(scoped_name.get());
   if (try_catch.HasException())
     return PP_MakeUndefined();
 
   if (!v8_method_name->IsString()) {
     try_catch.SetException(kUnableToCallMethodException);
     return PP_MakeUndefined();
   }
 
-  v8::Handle<v8::Object> function = accessor.GetObject();
-  v8::Handle<v8::Object> recv =
+  v8::Local<v8::Object> function = accessor.GetObject();
+  v8::Local<v8::Object> recv =
       accessor.instance()->GetMainWorldContext()->Global();
   if (v8_method_name.As<v8::String>()->Length() != 0) {
     function = function->Get(v8_method_name)
                    ->ToObject(accessor.instance()->GetIsolate());
     recv = accessor.GetObject();
   }
 
   if (try_catch.HasException())
     return PP_MakeUndefined();
 
   if (!function->IsFunction()) {
     try_catch.SetException(kUnableToCallMethodException);
     return PP_MakeUndefined();
   }
 
-  scoped_ptr<v8::Handle<v8::Value>[] > converted_args(
-      new v8::Handle<v8::Value>[argc]);
+  scoped_ptr<v8::Local<v8::Value>[] > converted_args(
+      new v8::Local<v8::Value>[argc]);
   for (uint32_t i = 0; i < argc; ++i) {
     converted_args[i] = try_catch.ToV8(argv[i]);
     if (try_catch.HasException())
       return PP_MakeUndefined();
   }
 
   blink::WebPluginContainer* container = accessor.instance()->container();
   blink::WebLocalFrame* frame = NULL;
   if (container)
     frame = container->element().document().frame();
 
   if (!frame) {
     try_catch.SetException("No frame to execute script in.");
     return PP_MakeUndefined();
   }
 
-  v8::Handle<v8::Value> result = frame->callFunctionEvenIfScriptDisabled(
+  v8::Local<v8::Value> result = frame->callFunctionEvenIfScriptDisabled(
       function.As<v8::Function>(), recv, argc, converted_args.get());
   ScopedPPVar result_var = try_catch.FromV8(result);
 
   if (try_catch.HasException())
     return PP_MakeUndefined();
 
   return result_var.Release();
 }
 
 PP_Var CallDeprecated(PP_Var var,
@@ skipping 17 matching lines @@
 }
 
 bool IsInstanceOfDeprecated(PP_Var var,
                             const PPP_Class_Deprecated* ppp_class,
                             void** ppp_class_data) {
   scoped_refptr<V8ObjectVar> object(V8ObjectVar::FromPPVar(var));
   if (!object.get())
     return false;  // Not an object at all.
 
   v8::HandleScope handle_scope(object->instance()->GetIsolate());
-  v8::Handle<v8::Context> context = object->instance()->GetMainWorldContext();
+  v8::Local<v8::Context> context = object->instance()->GetMainWorldContext();
   if (context.IsEmpty())
     return false;
   v8::Context::Scope context_scope(context);
   PluginObject* plugin_object = PluginObject::FromV8Object(
       object->instance()->GetIsolate(), object->GetHandle());
   if (plugin_object && plugin_object->ppp_class() == ppp_class) {
     if (ppp_class_data)
       *ppp_class_data = plugin_object->ppp_class_data();
     return true;
   }
@@ skipping 41 matching lines @@
       &CallDeprecated,
       &Construct,
       &IsInstanceOfDeprecated,
       &CreateObjectDeprecated,
       &CreateObjectWithModuleDeprecated, };
 
   return &var_deprecated_interface;
 }
 
 }  // namespace content