Use Local instead of Handle in src/content/*

content/renderer/pepper/host_var_tracker.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/host_var_tracker.h"
 
 #include "base/logging.h"
 #include "content/renderer/pepper/host_array_buffer_var.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/host_resource_var.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/v8object_var.h"
 #include "ppapi/c/pp_var.h"
 
 using ppapi::ArrayBufferVar;
 using ppapi::V8ObjectVar;
 
 namespace content {
 
 HostVarTracker::V8ObjectVarKey::V8ObjectVarKey(V8ObjectVar* object_var)
     : instance(object_var->instance()->pp_instance()) {
   v8::Local<v8::Object> object = object_var->GetHandle();
   hash = object.IsEmpty() ? 0 : object->GetIdentityHash();
 }
 
 HostVarTracker::V8ObjectVarKey::V8ObjectVarKey(PP_Instance instance,
-                                               v8::Handle<v8::Object> object)
+                                               v8::Local<v8::Object> object)
     : instance(instance),
       hash(object.IsEmpty() ? 0 : object->GetIdentityHash()) {}
 
 HostVarTracker::V8ObjectVarKey::~V8ObjectVarKey() {}
 
 bool HostVarTracker::V8ObjectVarKey::operator<(
     const V8ObjectVarKey& other) const {
   if (instance == other.instance)
     return hash < other.hash;
   return instance < other.instance;
@@ skipping 25 matching lines @@
 void HostVarTracker::RemoveV8ObjectVar(V8ObjectVar* object_var) {
   CheckThreadingPreconditions();
   v8::HandleScope handle_scope(object_var->instance()->GetIsolate());
   ObjectMap::iterator it = GetForV8Object(
       object_var->instance()->pp_instance(), object_var->GetHandle());
   DCHECK(it != object_map_.end());
   object_map_.erase(it);
 }
 
 PP_Var HostVarTracker::V8ObjectVarForV8Object(PP_Instance instance,
-                                              v8::Handle<v8::Object> object) {
+                                              v8::Local<v8::Object> object) {
   CheckThreadingPreconditions();
   ObjectMap::const_iterator it = GetForV8Object(instance, object);
   if (it == object_map_.end())
     return (new V8ObjectVar(instance, object))->GetPPVar();
   return it->second->GetPPVar();
 }
 
 int HostVarTracker::GetLiveV8ObjectVarsForTest(PP_Instance instance) {
   CheckThreadingPreconditions();
   int count = 0;
   // Use a key with an empty handle to find the v8 object var in the map with
   // the given instance and the lowest hash.
-  V8ObjectVarKey key(instance, v8::Handle<v8::Object>());
+  V8ObjectVarKey key(instance, v8::Local<v8::Object>());
   ObjectMap::const_iterator it = object_map_.lower_bound(key);
   while (it != object_map_.end() && it->first.instance == instance) {
     ++count;
     ++it;
   }
   return count;
 }
 
 PP_Var HostVarTracker::MakeResourcePPVarFromMessage(
     PP_Instance instance,
@@ skipping 15 matching lines @@
 
   PepperPluginInstanceImpl* instance =
       HostGlobals::Get()->GetInstance(pp_instance);
   v8::HandleScope handle_scope(instance->GetIsolate());
   // Force delete all var references. ForceReleaseV8Object() will cause
   // this object, and potentially others it references, to be removed from
   // |live_vars_|.
 
   // Use a key with an empty handle to find the v8 object var in the map with
   // the given instance and the lowest hash.
-  V8ObjectVarKey key(pp_instance, v8::Handle<v8::Object>());
+  V8ObjectVarKey key(pp_instance, v8::Local<v8::Object>());
   ObjectMap::iterator it = object_map_.lower_bound(key);
   while (it != object_map_.end() && it->first.instance == pp_instance) {
     ForceReleaseV8Object(it->second);
     object_map_.erase(it++);
   }
 }
 
 void HostVarTracker::ForceReleaseV8Object(ppapi::V8ObjectVar* object_var) {
   object_var->InstanceDeleted();
   VarMap::iterator iter = live_vars_.find(object_var->GetExistingVarID());
   if (iter == live_vars_.end()) {
     NOTREACHED();
     return;
   }
   iter->second.ref_count = 0;
   DCHECK(iter->second.track_with_no_reference_count == 0);
   DeleteObjectInfoIfNecessary(iter);
 }
 
 HostVarTracker::ObjectMap::iterator HostVarTracker::GetForV8Object(
     PP_Instance instance,
-    v8::Handle<v8::Object> object) {
+    v8::Local<v8::Object> object) {
   std::pair<ObjectMap::iterator, ObjectMap::iterator> range =
       object_map_.equal_range(V8ObjectVarKey(instance, object));
 
   for (ObjectMap::iterator it = range.first; it != range.second; ++it) {
     if (object == it->second->GetHandle())
       return it;
   }
   return object_map_.end();
 }
 
@@ skipping 25 matching lines @@
   if (it->second.instance != instance)
     return false;
 
   *handle = it->second.handle;
   *size_in_bytes = it->second.size_in_bytes;
   shared_memory_map_.erase(it);
   return true;
 }
 
 }  // namespace content