Use Local instead of Handle in src/content/*

content/renderer/pepper/message_channel.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/message_channel.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 103 matching lines @@
   v8::HandleScope scope(v8::Isolate::GetCurrent());
 
   // Because V8 is probably not on the stack for Native->JS calls, we need to
   // enter the appropriate context for the plugin.
   v8::Local<v8::Context> context = instance_->GetMainWorldContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
-  v8::Handle<v8::Value> v8_val;
+  v8::Local<v8::Value> v8_val;
   if (!var_converter_.ToV8Value(message_data, context, &v8_val)) {
     PpapiGlobals::Get()->LogWithSource(instance_->pp_instance(),
                                        PP_LOGLEVEL_ERROR,
                                        std::string(),
                                        kVarToV8ConversionError);
     return;
   }
 
   WebSerializedScriptValue serialized_val =
       WebSerializedScriptValue::serialize(v8_val);
@@ skipping 25 matching lines @@
 
   // We can't drain the JS message queue directly since we haven't finished
   // initializing the PepperWebPluginImpl yet, so the plugin isn't available in
   // the DOM.
   DrainJSMessageQueueSoon();
 
   plugin_message_queue_state_ = SEND_DIRECTLY;
   DrainCompletedPluginMessages();
 }
 
-void MessageChannel::SetPassthroughObject(v8::Handle<v8::Object> passthrough) {
+void MessageChannel::SetPassthroughObject(v8::Local<v8::Object> passthrough) {
   passthrough_object_.Reset(instance_->GetIsolate(), passthrough);
 }
 
 void MessageChannel::SetReadOnlyProperty(PP_Var key, PP_Var value) {
   StringVar* key_string = StringVar::FromPPVar(key);
   if (key_string) {
     internal_named_properties_[key_string->value()] = ScopedPPVar(value);
   } else {
     NOTREACHED();
   }
@@ skipping 42 matching lines @@
         ->GetFunction();
   } else if (identifier == kPostMessageAndAwaitResponse) {
     return GetFunctionTemplate(isolate, identifier,
                                &MessageChannel::PostBlockingMessageToNative)
         ->GetFunction();
   }
 
   std::map<std::string, ScopedPPVar>::const_iterator it =
       internal_named_properties_.find(identifier);
   if (it != internal_named_properties_.end()) {
-    v8::Handle<v8::Value> result = try_catch.ToV8(it->second.get());
+    v8::Local<v8::Value> result = try_catch.ToV8(it->second.get());
     if (try_catch.ThrowException())
       return v8::Local<v8::Value>();
     return result;
   }
 
   PluginObject* plugin_object = GetPluginObject(isolate);
   if (plugin_object)
     return plugin_object->GetNamedProperty(isolate, identifier);
   return v8::Local<v8::Value>();
 }
@@ skipping 33 matching lines @@
 
 void MessageChannel::PostMessageToNative(gin::Arguments* args) {
   if (!instance_)
     return;
   if (args->Length() != 1) {
     // TODO(raymes): Consider throwing an exception here. We don't now for
     // backward compatibility.
     return;
   }
 
-  v8::Handle<v8::Value> message_data;
+  v8::Local<v8::Value> message_data;
   if (!args->GetNext(&message_data)) {
     NOTREACHED();
   }
 
   EnqueuePluginMessage(message_data);
   DrainCompletedPluginMessages();
 }
 
 void MessageChannel::PostBlockingMessageToNative(gin::Arguments* args) {
   if (!instance_)
     return;
   PepperTryCatchV8 try_catch(instance_, &var_converter_, args->isolate());
   if (args->Length() != 1) {
     try_catch.ThrowException(
         "postMessageAndAwaitResponse requires one argument");
     return;
   }
 
-  v8::Handle<v8::Value> message_data;
+  v8::Local<v8::Value> message_data;
   if (!args->GetNext(&message_data)) {
     NOTREACHED();
   }
 
   if (plugin_message_queue_state_ == WAITING_TO_START) {
     try_catch.ThrowException(
         "Attempted to call a synchronous method on a plugin that was not "
         "yet loaded.");
     return;
   }
@@ skipping 21 matching lines @@
 
   ScopedPPVar pp_result;
   bool was_handled = instance_->HandleBlockingMessage(param, &pp_result);
   if (!was_handled) {
     try_catch.ThrowException(
         "The plugin has not registered a handler for synchronous messages. "
         "See the documentation for PPB_Messaging::RegisterMessageHandler "
         "and PPP_MessageHandler.");
     return;
   }
-  v8::Handle<v8::Value> v8_result = try_catch.ToV8(pp_result.get());
+  v8::Local<v8::Value> v8_result = try_catch.ToV8(pp_result.get());
   if (try_catch.ThrowException())
     return;
 
   args->Return(v8_result);
 }
 
 void MessageChannel::PostMessageToJavaScriptImpl(
     const WebSerializedScriptValue& message_data) {
   DCHECK(instance_);
 
@@ skipping 22 matching lines @@
   //     TODO(dmichael):  Add origin if we change to a more iframe-like origin
   //                      policy (see crbug.com/81537)
   container->element().dispatchEvent(msg_event);
 }
 
 PluginObject* MessageChannel::GetPluginObject(v8::Isolate* isolate) {
   return PluginObject::FromV8Object(isolate,
       v8::Local<v8::Object>::New(isolate, passthrough_object_));
 }
 
-void MessageChannel::EnqueuePluginMessage(v8::Handle<v8::Value> v8_value) {
+void MessageChannel::EnqueuePluginMessage(v8::Local<v8::Value> v8_value) {
   plugin_message_queue_.push_back(VarConversionResult());
   // Convert the v8 value in to an appropriate PP_Var like Dictionary,
   // Array, etc. (We explicitly don't want an "Object" PP_Var, which we don't
   // support for Messaging.)
   // TODO(raymes): Possibly change this to use TryCatch to do the conversion and
   // throw an exception if necessary.
   V8VarConverter::VarResult conversion_result =
       var_converter_.FromV8Value(
           v8_value,
           v8::Isolate::GetCurrent()->GetCurrentContext(),
@@ skipping 74 matching lines @@
   v8::Local<v8::FunctionTemplate> function_template = template_cache_.Get(name);
   if (!function_template.IsEmpty())
     return function_template;
   function_template = gin::CreateFunctionTemplate(
       isolate, base::Bind(memberFuncPtr, weak_ptr_factory_.GetWeakPtr()));
   template_cache_.Set(name, function_template);
   return function_template;
 }
 
 }  // namespace content