Use Local instead of Handle in src/content/*

content/renderer/pepper/resource_converter.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 "content/renderer/pepper/resource_converter.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/pepper_file_system_host.h"
@@ skipping 104 matching lines @@
       new PpapiPluginMsg_FileSystem_CreateFromPendingHost(file_system_type));
 
   browser_host_create_message->reset(
       new PpapiHostMsg_FileSystem_CreateFromRenderer(root_url.spec(),
                                                      file_system_type));
   return true;
 }
 
 bool ResourceHostToDOMFileSystem(
     content::PepperFileSystemHost* file_system_host,
-    v8::Handle<v8::Context> context,
-    v8::Handle<v8::Value>* dom_file_system) {
+    v8::Local<v8::Context> context,
+    v8::Local<v8::Value>* dom_file_system) {
   GURL root_url = file_system_host->GetRootUrl();
   GURL origin;
   storage::FileSystemType type;
   base::FilePath virtual_path;
   storage::ParseFileSystemSchemeURL(root_url, &origin, &type, &virtual_path);
 
   std::string name = storage::GetFileSystemName(origin, type);
   blink::WebFileSystemType blink_type;
   if (!FileApiFileSystemTypeToWebFileSystemType(type, &blink_type))
     return false;
   blink::WebLocalFrame* frame = blink::WebLocalFrame::frameForContext(context);
   blink::WebDOMFileSystem web_dom_file_system = blink::WebDOMFileSystem::create(
       frame,
       blink_type,
       blink::WebString::fromUTF8(name),
       root_url,
       blink::WebDOMFileSystem::SerializableTypeSerializable);
   *dom_file_system =
       web_dom_file_system.toV8Value(context->Global(), context->GetIsolate());
   return true;
 }
 
 bool ResourceHostToDOMMediaStreamVideoTrack(
     content::PepperMediaStreamVideoTrackHost* host,
-    v8::Handle<v8::Context> context,
-    v8::Handle<v8::Value>* dom_video_track) {
+    v8::Local<v8::Context> context,
+    v8::Local<v8::Value>* dom_video_track) {
   // TODO(ronghuawu): Implement this once crbug/352219 is resolved.
   // blink::WebMediaStreamTrack track = host->track();
   // *dom_video_track = track.toV8Value();
   return false;
 }
 
 bool DOMMediaStreamTrackToResource(
     PP_Instance instance,
     RendererPpapiHost* host,
     const blink::WebDOMMediaStreamTrack& dom_media_stream_track,
@@ skipping 36 matching lines @@
 
 ResourceConverterImpl::ResourceConverterImpl(PP_Instance instance)
     : instance_(instance) {}
 
 ResourceConverterImpl::~ResourceConverterImpl() {
   // Verify Flush() was called.
   DCHECK(browser_host_create_messages_.empty());
   DCHECK(browser_vars_.empty());
 }
 
-bool ResourceConverterImpl::FromV8Value(v8::Handle<v8::Object> val,
-                                        v8::Handle<v8::Context> context,
+bool ResourceConverterImpl::FromV8Value(v8::Local<v8::Object> val,
+                                        v8::Local<v8::Context> context,
                                         PP_Var* result,
                                         bool* was_resource) {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope(context->GetIsolate());
   RendererPpapiHost* host = RendererPpapiHost::GetForPPInstance(instance_);
 
   *was_resource = false;
 
   blink::WebDOMFileSystem dom_file_system =
       blink::WebDOMFileSystem::fromV8Value(val);
@@ skipping 57 matching lines @@
 void ResourceConverterImpl::Flush(const base::Callback<void(bool)>& callback) {
   RendererPpapiHost::GetForPPInstance(instance_)->CreateBrowserResourceHosts(
       instance_,
       browser_host_create_messages_,
       base::Bind(&FlushComplete, callback, browser_vars_));
   browser_host_create_messages_.clear();
   browser_vars_.clear();
 }
 
 bool ResourceConverterImpl::ToV8Value(const PP_Var& var,
-                                      v8::Handle<v8::Context> context,
-                                      v8::Handle<v8::Value>* result) {
+                                      v8::Local<v8::Context> context,
+                                      v8::Local<v8::Value>* result) {
   DCHECK(var.type == PP_VARTYPE_RESOURCE);
 
   ResourceVar* resource = ResourceVar::FromPPVar(var);
   if (!resource) {
     NOTREACHED();
     return false;
   }
   PP_Resource resource_id = resource->GetPPResource();
 
   // Get the renderer-side resource host for this resource.
@@ skipping 44 matching lines @@
     const IPC::Message& create_message,
     const IPC::Message& browser_host_create_message) {
   scoped_refptr<HostResourceVar> result =
       CreateResourceVar(pending_renderer_id, create_message);
   browser_host_create_messages_.push_back(browser_host_create_message);
   browser_vars_.push_back(result);
   return result;
 }
 
 }  // namespace content