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

extensions/renderer/guest_view/extensions_guest_view_container.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/guest_view/extensions_guest_view_container.h"
 
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/guest_view/guest_view_constants.h"
 #include "extensions/common/guest_view/guest_view_messages.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 namespace {
 typedef std::map<int, extensions::ExtensionsGuestViewContainer*>
     ExtensionsGuestViewContainerMap;
 static base::LazyInstance<ExtensionsGuestViewContainerMap>
     g_guest_view_container_map = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 namespace extensions {
 
-ExtensionsGuestViewContainer::Request::Request(
-    GuestViewContainer* container,
-    v8::Handle<v8::Function> callback,
-    v8::Isolate* isolate)
+ExtensionsGuestViewContainer::Request::Request(GuestViewContainer* container,
+                                               v8::Local<v8::Function> callback,
+                                               v8::Isolate* isolate)
     : container_(container), callback_(isolate, callback), isolate_(isolate) {
 }
 
 ExtensionsGuestViewContainer::Request::~Request() {
 }
 
 bool ExtensionsGuestViewContainer::Request::HasCallback() const {
   return !callback_.IsEmpty();
 }
 
-v8::Handle<v8::Function>
-ExtensionsGuestViewContainer::Request::GetCallback() const {
+v8::Local<v8::Function> ExtensionsGuestViewContainer::Request::GetCallback()
+    const {
   return v8::Local<v8::Function>::New(isolate_, callback_);
 }
 
 void ExtensionsGuestViewContainer::Request::ExecuteCallbackIfAvailable(
-    int argc, scoped_ptr<v8::Handle<v8::Value>[]> argv) {
+    int argc,
+    scoped_ptr<v8::Local<v8::Value>[]> argv) {
   if (!HasCallback())
     return;
 
   v8::HandleScope handle_scope(isolate());
-  v8::Handle<v8::Function> callback = GetCallback();
-  v8::Handle<v8::Context> context = callback->CreationContext();
+  v8::Local<v8::Function> callback = GetCallback();
+  v8::Local<v8::Context> context = callback->CreationContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
   blink::WebScopedMicrotaskSuppression suppression;
 
   // Call the AttachGuest API's callback with the guest proxy as the first
   // parameter.
   callback->Call(context->Global(), argc, argv.get());
 }
 
 ExtensionsGuestViewContainer::AttachRequest::AttachRequest(
     GuestViewContainer* container,
     int guest_instance_id,
     scoped_ptr<base::DictionaryValue> params,
-    v8::Handle<v8::Function> callback,
+    v8::Local<v8::Function> callback,
     v8::Isolate* isolate)
     : Request(container, callback, isolate),
       guest_instance_id_(guest_instance_id),
       params_(params.Pass()) {
 }
 
 ExtensionsGuestViewContainer::AttachRequest::~AttachRequest() {
 }
 
 void ExtensionsGuestViewContainer::AttachRequest::PerformRequest() {
@@ skipping 20 matching lines @@
       content::RenderView::FromRoutingID(get<1>(param));
   // TODO(fsamuel): Should we be reporting an error to JavaScript or DCHECKing?
   if (!guest_proxy_render_view)
     return;
 
   v8::HandleScope handle_scope(isolate());
   blink::WebFrame* frame = guest_proxy_render_view->GetWebView()->mainFrame();
   v8::Local<v8::Value> window = frame->mainWorldScriptContext()->Global();
 
   const int argc = 1;
-  scoped_ptr<v8::Handle<v8::Value>[]> argv(new v8::Handle<v8::Value>[argc]);
+  scoped_ptr<v8::Local<v8::Value>[]> argv(new v8::Local<v8::Value>[argc]);
   argv[0] = window;
 
   ExecuteCallbackIfAvailable(argc, argv.Pass());
 }
 
 ExtensionsGuestViewContainer::DetachRequest::DetachRequest(
     GuestViewContainer* container,
-    v8::Handle<v8::Function> callback,
+    v8::Local<v8::Function> callback,
     v8::Isolate* isolate)
     : Request(container, callback, isolate) {
 }
 
 ExtensionsGuestViewContainer::DetachRequest::~DetachRequest() {
 }
 
 void ExtensionsGuestViewContainer::DetachRequest::PerformRequest() {
   if (!container()->render_frame())
     return;
@@ skipping 25 matching lines @@
   while (pending_requests_.size() > 0) {
     linked_ptr<Request> pending_request = pending_requests_.front();
     pending_requests_.pop_front();
     // Call the JavaScript callbacks with no arguments which implies an error.
     pending_request->ExecuteCallbackIfAvailable(0 /* argc */, nullptr);
   }
 
   // Call the destruction callback, if one is registered.
   if (!destruction_callback_.IsEmpty()) {
     v8::HandleScope handle_scope(destruction_isolate_);
-    v8::Handle<v8::Function> callback =
-        v8::Local<v8::Function>::New(destruction_isolate_,
-                                     destruction_callback_);
-    v8::Handle<v8::Context> context = callback->CreationContext();
+    v8::Local<v8::Function> callback = v8::Local<v8::Function>::New(
+        destruction_isolate_, destruction_callback_);
+    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 /* argc */, nullptr);
   }
 }
 
 ExtensionsGuestViewContainer* ExtensionsGuestViewContainer::FromID(
     int element_instance_id) {
   ExtensionsGuestViewContainerMap* guest_view_containers =
       g_guest_view_container_map.Pointer();
   auto it = guest_view_containers->find(element_instance_id);
   return it == guest_view_containers->end() ? nullptr : it->second;
 }
 
 void ExtensionsGuestViewContainer::IssueRequest(linked_ptr<Request> request) {
   EnqueueRequest(request);
   PerformPendingRequest();
 }
 
 void ExtensionsGuestViewContainer::RegisterDestructionCallback(
-    v8::Handle<v8::Function> callback,
+    v8::Local<v8::Function> callback,
     v8::Isolate* isolate) {
   destruction_callback_.Reset(isolate, callback);
   destruction_isolate_ = isolate;
 }
 
 void ExtensionsGuestViewContainer::RegisterElementResizeCallback(
-    v8::Handle<v8::Function> callback,
+    v8::Local<v8::Function> callback,
     v8::Isolate* isolate) {
   element_resize_callback_.Reset(isolate, callback);
   element_resize_isolate_ = isolate;
 }
 
 void ExtensionsGuestViewContainer::DidResizeElement(const gfx::Size& old_size,
                                                     const gfx::Size& new_size) {
   // Call the element resize callback, if one is registered.
   if (element_resize_callback_.IsEmpty())
     return;
@@ skipping 31 matching lines @@
   // Handle the callback for the current request with a pending response.
   HandlePendingResponseCallback(message);
   // Perform the subsequent attach request if one exists.
   PerformPendingRequest();
 }
 
 void ExtensionsGuestViewContainer::CallElementResizeCallback(
     const gfx::Size& old_size,
     const gfx::Size& new_size) {
   v8::HandleScope handle_scope(element_resize_isolate_);
-  v8::Handle<v8::Function> callback = v8::Local<v8::Function>::New(
+  v8::Local<v8::Function> callback = v8::Local<v8::Function>::New(
       element_resize_isolate_, element_resize_callback_);
-  v8::Handle<v8::Context> context = callback->CreationContext();
+  v8::Local<v8::Context> context = callback->CreationContext();
   if (context.IsEmpty())
     return;
 
   const int argc = 4;
-  v8::Handle<v8::Value> argv[argc] = {
-    v8::Integer::New(element_resize_isolate_, old_size.width()),
-    v8::Integer::New(element_resize_isolate_, old_size.height()),
-    v8::Integer::New(element_resize_isolate_, new_size.width()),
-    v8::Integer::New(element_resize_isolate_, new_size.height())};
+  v8::Local<v8::Value> argv[argc] = {
+      v8::Integer::New(element_resize_isolate_, old_size.width()),
+      v8::Integer::New(element_resize_isolate_, old_size.height()),
+      v8::Integer::New(element_resize_isolate_, new_size.width()),
+      v8::Integer::New(element_resize_isolate_, new_size.height())};
 
   v8::Context::Scope context_scope(context);
   blink::WebScopedMicrotaskSuppression suppression;
 
   callback->Call(context->Global(), argc, argv);
 }
 
 void ExtensionsGuestViewContainer::EnqueueRequest(linked_ptr<Request> request) {
   pending_requests_.push_back(request);
 }
 
 void ExtensionsGuestViewContainer::PerformPendingRequest() {
   if (!ready_ || pending_requests_.empty() || pending_response_.get())
     return;
 
   linked_ptr<Request> pending_request = pending_requests_.front();
   pending_requests_.pop_front();
   pending_request->PerformRequest();
   pending_response_ = pending_request;
 }
 
 void ExtensionsGuestViewContainer::HandlePendingResponseCallback(
     const IPC::Message& message) {
   CHECK(pending_response_.get());
   linked_ptr<Request> pending_response(pending_response_.release());
   pending_response->HandleResponse(message);
 }
 
 }  // namespace extensions