Use Local instead of Handle in src/content/*

content/shell/renderer/test_runner/web_ax_object_proxy.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 "content/shell/renderer/test_runner/web_ax_object_proxy.h"
 
 #include "base/strings/stringprintf.h"
 #include "gin/handle.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
@@ skipping 579 matching lines @@
       //
       .SetProperty("name", &WebAXObjectProxy::Name)
       .SetProperty("nameFrom", &WebAXObjectProxy::NameFrom)
       .SetMethod("nameElementCount", &WebAXObjectProxy::NameElementCount)
       .SetMethod("nameElementAtIndex", &WebAXObjectProxy::NameElementAtIndex);
       // TODO(dmazzoni): add "description", etc. once LayoutTests have
       // been updated to call deprecatedDescription instead.
 
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::GetChildAtIndex(unsigned index) {
+v8::Local<v8::Object> WebAXObjectProxy::GetChildAtIndex(unsigned index) {
   return factory_->GetOrCreate(accessibility_object_.childAt(index));
 }
 
 bool WebAXObjectProxy::IsRoot() const {
   return false;
 }
 
 bool WebAXObjectProxy::IsEqualToObject(const blink::WebAXObject& other) {
   return accessibility_object_.equals(other);
 }
 
 void WebAXObjectProxy::NotificationReceived(
     blink::WebFrame* frame,
     const std::string& notification_name) {
   if (notification_callback_.IsEmpty())
     return;
 
-  v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
+  v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
 
-  v8::Handle<v8::Value> argv[] = {
+  v8::Local<v8::Value> argv[] = {
     v8::String::NewFromUtf8(isolate, notification_name.data(),
                             v8::String::kNormalString,
                             notification_name.size()),
   };
   frame->callFunctionEvenIfScriptDisabled(
       v8::Local<v8::Function>::New(isolate, notification_callback_),
       context->Global(),
       arraysize(argv),
       argv);
 }
@@ skipping 244 matching lines @@
 bool WebAXObjectProxy::IsClickable() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.isClickable();
 }
 
 bool WebAXObjectProxy::IsButtonStateMixed() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.isButtonStateMixed();
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::AriaControlsElementAtIndex(
+v8::Local<v8::Object> WebAXObjectProxy::AriaControlsElementAtIndex(
                                                                 unsigned index)
 {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebVector<blink::WebAXObject> elements;
   accessibility_object_.ariaControls(elements);
   size_t elementCount = elements.size();
   if (index >= elementCount)
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(elements[index]);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::AriaFlowToElementAtIndex(
+v8::Local<v8::Object> WebAXObjectProxy::AriaFlowToElementAtIndex(
                                                                 unsigned index)
 {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebVector<blink::WebAXObject> elements;
   accessibility_object_.ariaFlowTo(elements);
   size_t elementCount = elements.size();
   if (index >= elementCount)
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(elements[index]);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::AriaOwnsElementAtIndex(unsigned index)
+v8::Local<v8::Object> WebAXObjectProxy::AriaOwnsElementAtIndex(unsigned index)
 {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebVector<blink::WebAXObject> elements;
   accessibility_object_.ariaOwns(elements);
   size_t elementCount = elements.size();
   if (index >= elementCount)
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(elements[index]);
 }
 
 std::string WebAXObjectProxy::AllAttributes() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return GetAttributes(accessibility_object_);
 }
 
 std::string WebAXObjectProxy::AttributesOfChildren() {
@@ skipping 36 matching lines @@
     bounds.x = std::min(bounds.x, next.x);
     bounds.y = std::min(bounds.y, next.y);
     bounds.width = right - bounds.x;
     bounds.height = bottom - bounds.y;
   }
 
   return base::StringPrintf("{x: %d, y: %d, width: %d, height: %d}",
                             bounds.x, bounds.y, bounds.width, bounds.height);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::ChildAtIndex(int index) {
+v8::Local<v8::Object> WebAXObjectProxy::ChildAtIndex(int index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   return GetChildAtIndex(index);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::ElementAtPoint(int x, int y) {
+v8::Local<v8::Object> WebAXObjectProxy::ElementAtPoint(int x, int y) {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebPoint point(x, y);
   blink::WebAXObject obj = accessibility_object_.hitTest(point);
   if (obj.isNull())
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::TableHeader() {
+v8::Local<v8::Object> WebAXObjectProxy::TableHeader() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject obj = accessibility_object_.headerContainerObject();
   if (obj.isNull())
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::RowHeaderAtIndex(unsigned index) {
+v8::Local<v8::Object> WebAXObjectProxy::RowHeaderAtIndex(unsigned index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebVector<blink::WebAXObject> headers;
   accessibility_object_.rowHeaders(headers);
   size_t headerCount = headers.size();
   if (index >= headerCount)
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(headers[index]);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::ColumnHeaderAtIndex(unsigned index) {
+v8::Local<v8::Object> WebAXObjectProxy::ColumnHeaderAtIndex(unsigned index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebVector<blink::WebAXObject> headers;
   accessibility_object_.columnHeaders(headers);
   size_t headerCount = headers.size();
   if (index >= headerCount)
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(headers[index]);
 }
 
 std::string WebAXObjectProxy::RowIndexRange() {
   accessibility_object_.updateLayoutAndCheckValidity();
   unsigned row_index = accessibility_object_.cellRowIndex();
   unsigned row_span = accessibility_object_.cellRowSpan();
   return base::StringPrintf("{%d, %d}", row_index, row_span);
 }
 
 std::string WebAXObjectProxy::ColumnIndexRange() {
   accessibility_object_.updateLayoutAndCheckValidity();
   unsigned column_index = accessibility_object_.cellColumnIndex();
   unsigned column_span = accessibility_object_.cellColumnSpan();
   return base::StringPrintf("{%d, %d}", column_index, column_span);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::CellForColumnAndRow(
+v8::Local<v8::Object> WebAXObjectProxy::CellForColumnAndRow(
     int column, int row) {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject obj =
       accessibility_object_.cellForColumnAndRow(column, row);
   if (obj.isNull())
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::DeprecatedTitleUIElement() {
+v8::Local<v8::Object> WebAXObjectProxy::DeprecatedTitleUIElement() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject obj = accessibility_object_.deprecatedTitleUIElement();
   if (obj.isNull())
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
 void WebAXObjectProxy::SetSelectedTextRange(int selection_start,
                                             int length) {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.setSelectedTextRange(selection_start,
                                               selection_start + length);
 }
@@ skipping 14 matching lines @@
 bool WebAXObjectProxy::IsIncrementActionSupported() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.canIncrement();
 }
 
 bool WebAXObjectProxy::IsDecrementActionSupported() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.canDecrement();
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::ParentElement() {
+v8::Local<v8::Object> WebAXObjectProxy::ParentElement() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject parent_object = accessibility_object_.parentObject();
   while (parent_object.accessibilityIsIgnored())
     parent_object = parent_object.parentObject();
   return factory_->GetOrCreate(parent_object);
 }
 
 void WebAXObjectProxy::Increment() {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.increment();
 }
 
 void WebAXObjectProxy::Decrement() {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.decrement();
 }
 
 void WebAXObjectProxy::ShowMenu() {
 }
 
 void WebAXObjectProxy::Press() {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.press();
 }
 
-bool WebAXObjectProxy::IsEqual(v8::Handle<v8::Object> proxy) {
+bool WebAXObjectProxy::IsEqual(v8::Local<v8::Object> proxy) {
   WebAXObjectProxy* unwrapped_proxy = NULL;
   if (!gin::ConvertFromV8(blink::mainThreadIsolate(), proxy, &unwrapped_proxy))
     return false;
   return unwrapped_proxy->IsEqualToObject(accessibility_object_);
 }
 
 void WebAXObjectProxy::SetNotificationListener(
-    v8::Handle<v8::Function> callback) {
+    v8::Local<v8::Function> callback) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   notification_callback_.Reset(isolate, callback);
 }
 
 void WebAXObjectProxy::UnsetNotificationListener() {
   notification_callback_.Reset();
 }
 
 void WebAXObjectProxy::TakeFocus() {
   accessibility_object_.updateLayoutAndCheckValidity();
@@ skipping 66 matching lines @@
 }
 
 int WebAXObjectProxy::NameElementCount() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXNameFrom nameFrom;
   blink::WebVector<blink::WebAXObject> nameObjects;
   accessibility_object_.name(nameFrom, nameObjects);
   return static_cast<int>(nameObjects.size());
 }
 
-v8::Handle<v8::Object> WebAXObjectProxy::NameElementAtIndex(unsigned index) {
+v8::Local<v8::Object> WebAXObjectProxy::NameElementAtIndex(unsigned index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXNameFrom nameFrom;
   blink::WebVector<blink::WebAXObject> nameObjects;
   accessibility_object_.name(nameFrom, nameObjects);
   if (index >= nameObjects.size())
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
   return factory_->GetOrCreate(nameObjects[index]);
 }
 
 RootWebAXObjectProxy::RootWebAXObjectProxy(
     const blink::WebAXObject &object, Factory *factory)
     : WebAXObjectProxy(object, factory) {
 }
 
-v8::Handle<v8::Object> RootWebAXObjectProxy::GetChildAtIndex(unsigned index) {
+v8::Local<v8::Object> RootWebAXObjectProxy::GetChildAtIndex(unsigned index) {
   if (index)
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   return factory()->GetOrCreate(accessibility_object());
 }
 
 bool RootWebAXObjectProxy::IsRoot() const {
   return true;
 }
 
 WebAXObjectProxyList::WebAXObjectProxyList()
     : elements_(blink::mainThreadIsolate()) {
@@ skipping 11 matching lines @@
     WebAXObjectProxy* unwrapped_object = NULL;
     bool result = gin::ConvertFromV8(isolate, elements_.Get(i),
                                      &unwrapped_object);
     DCHECK(result);
     DCHECK(unwrapped_object);
     unwrapped_object->Reset();
   }
   elements_.Clear();
 }
 
-v8::Handle<v8::Object> WebAXObjectProxyList::GetOrCreate(
+v8::Local<v8::Object> WebAXObjectProxyList::GetOrCreate(
     const blink::WebAXObject& object) {
   if (object.isNull())
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
 
   size_t elementCount = elements_.Size();
   for (size_t i = 0; i < elementCount; i++) {
     WebAXObjectProxy* unwrapped_object = NULL;
     bool result = gin::ConvertFromV8(isolate, elements_.Get(i),
                                      &unwrapped_object);
     DCHECK(result);
     DCHECK(unwrapped_object);
     if (unwrapped_object->IsEqualToObject(object))
       return elements_.Get(i);
   }
 
-  v8::Handle<v8::Value> value_handle = gin::CreateHandle(
+  v8::Local<v8::Value> value_handle = gin::CreateHandle(
       isolate, new WebAXObjectProxy(object, this)).ToV8();
   if (value_handle.IsEmpty())
-    return v8::Handle<v8::Object>();
-  v8::Handle<v8::Object> handle = value_handle->ToObject(isolate);
+    return v8::Local<v8::Object>();
+  v8::Local<v8::Object> handle = value_handle->ToObject(isolate);
   elements_.Append(handle);
   return handle;
 }
 
 }  // namespace content