extensions/renderer: Use v8::Local instead of v8::Handle.

extensions/renderer/messaging_bindings.cc

 // Copyright 2014 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 "extensions/renderer/messaging_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 164 matching lines @@
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_CloseChannel(port_id, std::string()));
       ClearPortDataAndNotifyDispatcher(port_id);
     }
   }
 
   // Holds a |callback| to run sometime after |object| is GC'ed. |callback| will
   // not be executed re-entrantly to avoid running JS in an unexpected state.
   class GCCallback {
    public:
-    static void Bind(v8::Handle<v8::Object> object,
-                     v8::Handle<v8::Function> callback,
+    static void Bind(v8::Local<v8::Object> object,
+                     v8::Local<v8::Function> callback,
                      v8::Isolate* isolate) {
       GCCallback* cb = new GCCallback(object, callback, isolate);
       cb->object_.SetWeak(cb, FirstWeakCallback,
                           v8::WeakCallbackType::kParameter);
     }
 
    private:
     static void FirstWeakCallback(
         const v8::WeakCallbackInfo<GCCallback>& data) {
       // v8 says we need to explicitly reset weak handles from their callbacks.
       // It's not implicit as one might expect.
       data.GetParameter()->object_.Reset();
       data.SetSecondPassCallback(SecondWeakCallback);
     }
 
     static void SecondWeakCallback(
         const v8::WeakCallbackInfo<GCCallback>& data) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&GCCallback::RunCallback,
                      base::Owned(data.GetParameter())));
     }
 
-    GCCallback(v8::Handle<v8::Object> object,
-               v8::Handle<v8::Function> callback,
+    GCCallback(v8::Local<v8::Object> object,
+               v8::Local<v8::Function> callback,
                v8::Isolate* isolate)
         : object_(isolate, object),
           callback_(isolate, callback),
           isolate_(isolate) {}
 
     void RunCallback() {
       v8::HandleScope handle_scope(isolate_);
-      v8::Handle<v8::Function> callback =
+      v8::Local<v8::Function> callback =
           v8::Local<v8::Function>::New(isolate_, callback_);
-      v8::Handle<v8::Context> context = callback->CreationContext();
+      v8::Local<v8::Context> context = callback->CreationContext();
       if (context.IsEmpty())
         return;
       v8::Context::Scope context_scope(context);
       blink::WebScopedMicrotaskSuppression suppression;
       callback->Call(context->Global(), 0, NULL);
     }
 
     v8::Global<v8::Object> object_;
     v8::Global<v8::Function> callback_;
     v8::Isolate* isolate_;
@@ skipping 35 matching lines @@
     return;
   v8::Isolate* isolate = script_context->isolate();
   v8::HandleScope handle_scope(isolate);
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 
   const std::string& source_url_spec = info.source_url.spec();
   std::string target_extension_id = script_context->GetExtensionID();
   const Extension* extension = script_context->extension();
 
-  v8::Handle<v8::Value> tab = v8::Null(isolate);
-  v8::Handle<v8::Value> tls_channel_id_value = v8::Undefined(isolate);
-  v8::Handle<v8::Value> guest_process_id = v8::Undefined(isolate);
+  v8::Local<v8::Value> tab = v8::Null(isolate);
+  v8::Local<v8::Value> tls_channel_id_value = v8::Undefined(isolate);
+  v8::Local<v8::Value> guest_process_id = v8::Undefined(isolate);
 
   if (extension) {
     if (!source->tab.empty() && !extension->is_platform_app())
       tab = converter->ToV8Value(&source->tab, script_context->v8_context());
 
     ExternallyConnectableInfo* externally_connectable =
         ExternallyConnectableInfo::Get(extension);
     if (externally_connectable &&
         externally_connectable->accepts_tls_channel_id) {
       tls_channel_id_value = v8::String::NewFromUtf8(isolate,
                                                      tls_channel_id.c_str(),
                                                      v8::String::kNormalString,
                                                      tls_channel_id.size());
     }
 
     if (info.guest_process_id != content::ChildProcessHost::kInvalidUniqueID)
       guest_process_id = v8::Integer::New(isolate, info.guest_process_id);
   }
 
-  v8::Handle<v8::Value> arguments[] = {
+  v8::Local<v8::Value> arguments[] = {
       // portId
       v8::Integer::New(isolate, target_port_id),
       // channelName
-      v8::String::NewFromUtf8(isolate,
-                              channel_name.c_str(),
-                              v8::String::kNormalString,
-                              channel_name.size()),
+      v8::String::NewFromUtf8(isolate, channel_name.c_str(),
+                              v8::String::kNormalString, channel_name.size()),
       // sourceTab
       tab,
       // source_frame_id
       v8::Integer::New(isolate, source->frame_id),
       // guestProcessId
       guest_process_id,
       // sourceExtensionId
-      v8::String::NewFromUtf8(isolate,
-                              info.source_id.c_str(),
-                              v8::String::kNormalString,
-                              info.source_id.size()),
+      v8::String::NewFromUtf8(isolate, info.source_id.c_str(),
+                              v8::String::kNormalString, info.source_id.size()),
       // targetExtensionId
-      v8::String::NewFromUtf8(isolate,
-                              target_extension_id.c_str(),
+      v8::String::NewFromUtf8(isolate, target_extension_id.c_str(),
                               v8::String::kNormalString,
                               target_extension_id.size()),
       // sourceUrl
-      v8::String::NewFromUtf8(isolate,
-                              source_url_spec.c_str(),
+      v8::String::NewFromUtf8(isolate, source_url_spec.c_str(),
                               v8::String::kNormalString,
                               source_url_spec.size()),
       // tlsChannelId
       tls_channel_id_value,
   };
 
-  v8::Handle<v8::Value> retval =
+  v8::Local<v8::Value> retval =
       script_context->module_system()->CallModuleMethod(
           "messaging", "dispatchOnConnect", arraysize(arguments), arguments);
 
   if (!retval.IsEmpty()) {
     CHECK(retval->IsBoolean());
     *port_created |= retval->BooleanValue();
   } else {
     LOG(ERROR) << "Empty return value from dispatchOnConnect.";
   }
 }
 
 void DeliverMessageToScriptContext(const Message& message,
                                    int target_port_id,
                                    ScriptContext* script_context) {
   v8::Isolate* isolate = script_context->isolate();
   v8::HandleScope handle_scope(isolate);
 
   // Check to see whether the context has this port before bothering to create
   // the message.
-  v8::Handle<v8::Value> port_id_handle =
+  v8::Local<v8::Value> port_id_handle =
       v8::Integer::New(isolate, target_port_id);
-  v8::Handle<v8::Value> has_port =
-      script_context->module_system()->CallModuleMethod(
-          "messaging", "hasPort", 1, &port_id_handle);
+  v8::Local<v8::Value> has_port =
+      script_context->module_system()->CallModuleMethod("messaging", "hasPort",
+                                                        1, &port_id_handle);
 
   CHECK(!has_port.IsEmpty());
   if (!has_port->BooleanValue())
     return;
 
-  std::vector<v8::Handle<v8::Value> > arguments;
+  std::vector<v8::Local<v8::Value>> arguments;
   arguments.push_back(v8::String::NewFromUtf8(isolate,
                                               message.data.c_str(),
                                               v8::String::kNormalString,
                                               message.data.size()));
   arguments.push_back(port_id_handle);
 
   scoped_ptr<blink::WebScopedUserGesture> web_user_gesture;
   scoped_ptr<blink::WebScopedWindowFocusAllowedIndicator> allow_window_focus;
   if (message.user_gesture) {
     web_user_gesture.reset(new blink::WebScopedUserGesture);
 
     if (script_context->web_frame()) {
       blink::WebDocument document = script_context->web_frame()->document();
       allow_window_focus.reset(new blink::WebScopedWindowFocusAllowedIndicator(
           &document));
     }
   }
 
   script_context->module_system()->CallModuleMethod(
       "messaging", "dispatchOnMessage", &arguments);
 }
 
 void DispatchOnDisconnectToScriptContext(int port_id,
                                          const std::string& error_message,
                                          ScriptContext* script_context) {
   v8::Isolate* isolate = script_context->isolate();
   v8::HandleScope handle_scope(isolate);
 
-  std::vector<v8::Handle<v8::Value> > arguments;
+  std::vector<v8::Local<v8::Value>> arguments;
   arguments.push_back(v8::Integer::New(isolate, port_id));
   if (!error_message.empty()) {
     arguments.push_back(
         v8::String::NewFromUtf8(isolate, error_message.c_str()));
   } else {
     arguments.push_back(v8::Null(isolate));
   }
 
   script_context->module_system()->CallModuleMethod(
       "messaging", "dispatchOnDisconnect", &arguments);
@@ skipping 57 matching lines @@
   // TODO(robwu): ScriptContextSet.ForEach should accept RenderFrame*.
   content::RenderView* restrict_to_render_view =
       restrict_to_render_frame ? restrict_to_render_frame->GetRenderView()
                                : NULL;
   context_set.ForEach(
       restrict_to_render_view,
       base::Bind(&DispatchOnDisconnectToScriptContext, port_id, error_message));
 }
 
 }  // namespace extensions