Move //components/test_runner back into //content/shell

content/shell/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 "components/test_runner/web_ax_object_proxy.h"
+#include "content/shell/test_runner/web_ax_object_proxy.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "gin/handle.h"
 #include "third_party/WebKit/public/platform/WebFloatRect.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/skia/include/core/SkMatrix44.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 
 namespace test_runner {
 
 namespace {
 
 // Map role value to string, matching Safari/Mac platform implementation to
 // avoid rebaselining layout tests.
-std::string RoleToString(blink::WebAXRole role)
-{
+std::string RoleToString(blink::WebAXRole role) {
   std::string result = "AXRole: AX";
   switch (role) {
     case blink::WebAXRoleAbbr:
       return result.append("Abbr");
     case blink::WebAXRoleAlertDialog:
       return result.append("AlertDialog");
     case blink::WebAXRoleAlert:
       return result.append("Alert");
     case blink::WebAXRoleAnnotation:
       return result.append("Annotation");
@@ skipping 234 matching lines @@
   }
 }
 
 std::string GetStringValue(const blink::WebAXObject& object) {
   std::string value;
   if (object.role() == blink::WebAXRoleColorWell) {
     unsigned int color = object.colorValue();
     unsigned int red = (color >> 16) & 0xFF;
     unsigned int green = (color >> 8) & 0xFF;
     unsigned int blue = color & 0xFF;
-    value = base::StringPrintf("rgba(%d, %d, %d, 1)",
-                               red, green, blue);
+    value = base::StringPrintf("rgba(%d, %d, %d, 1)", red, green, blue);
   } else {
     value = object.stringValue().utf8();
   }
   return value.insert(0, "AXValue: ");
 }
 
 std::string GetRole(const blink::WebAXObject& object) {
   std::string role_string = RoleToString(object.role());
 
   // Special-case canvas with fallback content because Chromium wants to treat
@@ skipping 28 matching lines @@
 // of an object by calling getRelativeBounds and then applying the offsets
 // and transforms recursively on each container of this object.
 blink::WebFloatRect BoundsForObject(const blink::WebAXObject& object) {
   blink::WebAXObject container;
   blink::WebFloatRect bounds;
   SkMatrix44 matrix;
   object.getRelativeBounds(container, bounds, matrix);
   gfx::RectF computedBounds(0, 0, bounds.width, bounds.height);
   while (!container.isDetached()) {
     computedBounds.Offset(bounds.x, bounds.y);
-    computedBounds.Offset(
-        -container.getScrollOffset().x, -container.getScrollOffset().y);
+    computedBounds.Offset(-container.getScrollOffset().x,
+                          -container.getScrollOffset().y);
     if (!matrix.isIdentity()) {
       gfx::Transform transform(matrix);
       transform.TransformRect(&computedBounds);
     }
     container.getRelativeBounds(container, bounds, matrix);
   }
-  return blink::WebFloatRect(computedBounds.x(),
-                             computedBounds.y(),
-                             computedBounds.width(),
-                             computedBounds.height());
+  return blink::WebFloatRect(computedBounds.x(), computedBounds.y(),
+                             computedBounds.width(), computedBounds.height());
 }
 
 blink::WebRect BoundsForCharacter(const blink::WebAXObject& object,
                                   int characterIndex) {
   DCHECK_EQ(object.role(), blink::WebAXRoleStaticText);
   int end = 0;
   for (unsigned i = 0; i < object.childCount(); i++) {
     blink::WebAXObject inline_text_box = object.childAt(i);
     DCHECK_EQ(inline_text_box.role(), blink::WebAXRoleInlineTextBox);
     int start = end;
     blink::WebString name = inline_text_box.name();
     end += name.length();
     if (characterIndex < start || characterIndex >= end)
       continue;
 
     blink::WebFloatRect inline_text_box_rect = BoundsForObject(inline_text_box);
 
     int localIndex = characterIndex - start;
     blink::WebVector<int> character_offsets;
     inline_text_box.characterOffsets(character_offsets);
     if (character_offsets.size() != name.length())
       return blink::WebRect();
 
     switch (inline_text_box.textDirection()) {
       case blink::WebAXTextDirectionLR: {
         if (localIndex) {
           int left = inline_text_box_rect.x + character_offsets[localIndex - 1];
-          int width = character_offsets[localIndex] -
-              character_offsets[localIndex - 1];
-          return blink::WebRect(left, inline_text_box_rect.y,
-                                width, inline_text_box_rect.height);
+          int width =
+              character_offsets[localIndex] - character_offsets[localIndex - 1];
+          return blink::WebRect(left, inline_text_box_rect.y, width,
+                                inline_text_box_rect.height);
         }
-        return blink::WebRect(
-            inline_text_box_rect.x, inline_text_box_rect.y,
-            character_offsets[0], inline_text_box_rect.height);
+        return blink::WebRect(inline_text_box_rect.x, inline_text_box_rect.y,
+                              character_offsets[0],
+                              inline_text_box_rect.height);
       }
       case blink::WebAXTextDirectionRL: {
         int right = inline_text_box_rect.x + inline_text_box_rect.width;
 
         if (localIndex) {
           int left = right - character_offsets[localIndex];
-          int width = character_offsets[localIndex] -
-              character_offsets[localIndex - 1];
-          return blink::WebRect(left, inline_text_box_rect.y,
-                                width, inline_text_box_rect.height);
+          int width =
+              character_offsets[localIndex] - character_offsets[localIndex - 1];
+          return blink::WebRect(left, inline_text_box_rect.y, width,
+                                inline_text_box_rect.height);
         }
         int left = right - character_offsets[0];
-        return blink::WebRect(
-            left, inline_text_box_rect.y,
-            character_offsets[0], inline_text_box_rect.height);
+        return blink::WebRect(left, inline_text_box_rect.y,
+                              character_offsets[0],
+                              inline_text_box_rect.height);
       }
       case blink::WebAXTextDirectionTB: {
         if (localIndex) {
           int top = inline_text_box_rect.y + character_offsets[localIndex - 1];
-          int height = character_offsets[localIndex] -
-              character_offsets[localIndex - 1];
+          int height =
+              character_offsets[localIndex] - character_offsets[localIndex - 1];
           return blink::WebRect(inline_text_box_rect.x, top,
                                 inline_text_box_rect.width, height);
         }
         return blink::WebRect(inline_text_box_rect.x, inline_text_box_rect.y,
                               inline_text_box_rect.width, character_offsets[0]);
       }
       case blink::WebAXTextDirectionBT: {
         int bottom = inline_text_box_rect.y + inline_text_box_rect.height;
 
         if (localIndex) {
           int top = bottom - character_offsets[localIndex];
-          int height = character_offsets[localIndex] -
-              character_offsets[localIndex - 1];
+          int height =
+              character_offsets[localIndex] - character_offsets[localIndex - 1];
           return blink::WebRect(inline_text_box_rect.x, top,
                                 inline_text_box_rect.width, height);
         }
         int top = bottom - character_offsets[0];
         return blink::WebRect(inline_text_box_rect.x, top,
                               inline_text_box_rect.width, character_offsets[0]);
       }
     }
   }
 
@@ skipping 117 matching lines @@
 
   void addObjectVectorAttribute(
       blink::WebAXObjectVectorAttribute attribute,
       const blink::WebVector<blink::WebAXObject>& value) override {
     object_vector_attributes[attribute] = value;
   }
 };
 
 }  // namespace
 
-gin::WrapperInfo WebAXObjectProxy::kWrapperInfo = {
-    gin::kEmbedderNativeGin};
+gin::WrapperInfo WebAXObjectProxy::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 WebAXObjectProxy::WebAXObjectProxy(const blink::WebAXObject& object,
                                    WebAXObjectProxy::Factory* factory)
-    : accessibility_object_(object),
-      factory_(factory) {
-}
+    : accessibility_object_(object), factory_(factory) {}
 
 WebAXObjectProxy::~WebAXObjectProxy() {}
 
-gin::ObjectTemplateBuilder
-WebAXObjectProxy::GetObjectTemplateBuilder(v8::Isolate* isolate) {
+gin::ObjectTemplateBuilder WebAXObjectProxy::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
   return gin::Wrappable<WebAXObjectProxy>::GetObjectTemplateBuilder(isolate)
       .SetProperty("role", &WebAXObjectProxy::Role)
       .SetProperty("stringValue", &WebAXObjectProxy::StringValue)
       .SetProperty("language", &WebAXObjectProxy::Language)
       .SetProperty("x", &WebAXObjectProxy::X)
       .SetProperty("y", &WebAXObjectProxy::Y)
       .SetProperty("width", &WebAXObjectProxy::Width)
       .SetProperty("height", &WebAXObjectProxy::Height)
       .SetProperty("intValue", &WebAXObjectProxy::IntValue)
       .SetProperty("minValue", &WebAXObjectProxy::MinValue)
@@ skipping 165 matching lines @@
   if (notification_callback_.IsEmpty())
     return;
 
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
 
   v8::Local<v8::Value> argv[] = {
-    v8::String::NewFromUtf8(isolate, notification_name.data(),
-                            v8::String::kNormalString,
-                            notification_name.size()),
+      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);
+      context->Global(), arraysize(argv), argv);
 }
 
-void WebAXObjectProxy::Reset()  {
+void WebAXObjectProxy::Reset() {
   notification_callback_.Reset();
 }
 
 std::string WebAXObjectProxy::Role() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return GetRole(accessibility_object_);
 }
 
 std::string WebAXObjectProxy::StringValue() {
   accessibility_object_.updateLayoutAndCheckValidity();
@@ skipping 45 matching lines @@
   return accessibility_object_.maxValueForRange();
 }
 
 std::string WebAXObjectProxy::ValueDescription() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return GetValueDescription(accessibility_object_);
 }
 
 int WebAXObjectProxy::ChildrenCount() {
   accessibility_object_.updateLayoutAndCheckValidity();
-  int count = 1; // Root object always has only one child, the WebView.
+  int count = 1;  // Root object always has only one child, the WebView.
   if (!IsRoot())
     count = accessibility_object_.childCount();
   return count;
 }
 
 v8::Local<v8::Value> WebAXObjectProxy::SelectionAnchorObject() {
   accessibility_object_.updateLayoutAndCheckValidity();
 
   blink::WebAXObject anchorObject;
   int anchorOffset = -1;
@@ skipping 30 matching lines @@
   accessibility_object_.updateLayoutAndCheckValidity();
 
   blink::WebAXObject anchorObject;
   int anchorOffset = -1;
   blink::WebAXTextAffinity anchorAffinity;
   blink::WebAXObject focusObject;
   int focusOffset = -1;
   blink::WebAXTextAffinity focusAffinity;
   accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
                                   focusObject, focusOffset, focusAffinity);
-  return anchorAffinity == blink::WebAXTextAffinityUpstream ?
-      "upstream" : "downstream";
+  return anchorAffinity == blink::WebAXTextAffinityUpstream ? "upstream"
+                                                            : "downstream";
 }
 
 v8::Local<v8::Value> WebAXObjectProxy::SelectionFocusObject() {
   accessibility_object_.updateLayoutAndCheckValidity();
 
   blink::WebAXObject anchorObject;
   int anchorOffset = -1;
   blink::WebAXTextAffinity anchorAffinity;
   blink::WebAXObject focusObject;
   int focusOffset = -1;
@@ skipping 27 matching lines @@
   accessibility_object_.updateLayoutAndCheckValidity();
 
   blink::WebAXObject anchorObject;
   int anchorOffset = -1;
   blink::WebAXTextAffinity anchorAffinity;
   blink::WebAXObject focusObject;
   int focusOffset = -1;
   blink::WebAXTextAffinity focusAffinity;
   accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
                                   focusObject, focusOffset, focusAffinity);
-  return focusAffinity == blink::WebAXTextAffinityUpstream ?
-      "upstream" : "downstream";
+  return focusAffinity == blink::WebAXTextAffinityUpstream ? "upstream"
+                                                           : "downstream";
 }
 
 int WebAXObjectProxy::SelectionStart() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.selectionStart();
 }
 
 int WebAXObjectProxy::SelectionEnd() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.selectionEnd();
@@ skipping 130 matching lines @@
 
 float WebAXObjectProxy::FontSize() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.fontSize();
 }
 
 std::string WebAXObjectProxy::Orientation() {
   accessibility_object_.updateLayoutAndCheckValidity();
   if (accessibility_object_.orientation() == blink::WebAXOrientationVertical)
     return "AXOrientation: AXVerticalOrientation";
-  else if (accessibility_object_.orientation()
-           == blink::WebAXOrientationHorizontal)
+  else if (accessibility_object_.orientation() ==
+           blink::WebAXOrientationHorizontal)
     return "AXOrientation: AXHorizontalOrientation";
 
   return std::string();
 }
 
 int WebAXObjectProxy::PosInSet() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.posInSet();
 }
 
@@ skipping 24 matching lines @@
   blink::WebVector<blink::WebAXObject> headers;
   accessibility_object_.rowHeaders(headers);
   return static_cast<int32_t>(headers.size());
 }
 
 int32_t WebAXObjectProxy::ColumnCount() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return static_cast<int32_t>(accessibility_object_.columnCount());
 }
 
-int32_t WebAXObjectProxy::ColumnHeadersCount()
-{
+int32_t WebAXObjectProxy::ColumnHeadersCount() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebVector<blink::WebAXObject> headers;
   accessibility_object_.columnHeaders(headers);
   return static_cast<int32_t>(headers.size());
 }
 
 bool WebAXObjectProxy::IsClickable() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.isClickable();
 }
@@ skipping 26 matching lines @@
   blink::WebVector<blink::WebAXObject> elements =
       attribute_adapter.object_vector_attributes
           [blink::WebAXObjectVectorAttribute::AriaFlowTo];
   size_t elementCount = elements.size();
   if (index >= elementCount)
     return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(elements[index]);
 }
 
-v8::Local<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::Local<v8::Object>();
 
   return factory_->GetOrCreate(elements[index]);
 }
 
@@ skipping 38 matching lines @@
   for (int i = 1; i < len; i++) {
     blink::WebRect next = BoundsForCharacter(accessibility_object_, start + i);
     int right = std::max(bounds.x + bounds.width, next.x + next.width);
     int bottom = std::max(bounds.y + bounds.height, next.y + next.height);
     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);
+  return base::StringPrintf("{x: %d, y: %d, width: %d, height: %d}", bounds.x,
+                            bounds.y, bounds.width, bounds.height);
 }
 
 v8::Local<v8::Object> WebAXObjectProxy::ChildAtIndex(int index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   return GetChildAtIndex(index);
 }
 
 v8::Local<v8::Object> WebAXObjectProxy::ElementAtPoint(int x, int y) {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebPoint point(x, y);
@@ skipping 42 matching lines @@
   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::Local<v8::Object> WebAXObjectProxy::CellForColumnAndRow(
-    int column, int row) {
+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::Local<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
-void WebAXObjectProxy::SetSelectedTextRange(int selection_start,
-                                            int length) {
+void WebAXObjectProxy::SetSelectedTextRange(int selection_start, int length) {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.setSelectedTextRange(selection_start,
-                                              selection_start + length);
+                                             selection_start + length);
 }
 
-void WebAXObjectProxy::SetSelection(
-    v8::Local<v8::Value> anchor_object, int anchor_offset,
-    v8::Local<v8::Value> focus_object, int focus_offset) {
+void WebAXObjectProxy::SetSelection(v8::Local<v8::Value> anchor_object,
+                                    int anchor_offset,
+                                    v8::Local<v8::Value> focus_object,
+                                    int focus_offset) {
   if (anchor_object.IsEmpty() || focus_object.IsEmpty() ||
       !anchor_object->IsObject() || !focus_object->IsObject() ||
       anchor_offset < 0 || focus_offset < 0) {
     return;
   }
 
   WebAXObjectProxy* web_ax_anchor = nullptr;
-  if (!gin::ConvertFromV8(
-      blink::mainThreadIsolate(), anchor_object, &web_ax_anchor)) {
+  if (!gin::ConvertFromV8(blink::mainThreadIsolate(), anchor_object,
+                          &web_ax_anchor)) {
     return;
   }
   DCHECK(web_ax_anchor);
 
   WebAXObjectProxy* web_ax_focus = nullptr;
-  if (!gin::ConvertFromV8(
-      blink::mainThreadIsolate(), focus_object, &web_ax_focus)) {
+  if (!gin::ConvertFromV8(blink::mainThreadIsolate(), focus_object,
+                          &web_ax_focus)) {
     return;
   }
   DCHECK(web_ax_focus);
 
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.setSelection(
       web_ax_anchor->accessibility_object_, anchor_offset,
       web_ax_focus->accessibility_object_, focus_offset);
 }
 
@@ skipping 76 matching lines @@
 void WebAXObjectProxy::TakeFocus() {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.setFocused(true);
 }
 
 void WebAXObjectProxy::ScrollToMakeVisible() {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.scrollToMakeVisible();
 }
 
-void WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus(int x, int y,
-                                                       int width, int height) {
+void WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus(int x,
+                                                       int y,
+                                                       int width,
+                                                       int height) {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.scrollToMakeVisibleWithSubFocus(
       blink::WebRect(x, y, width, height));
 }
 
 void WebAXObjectProxy::ScrollToGlobalPoint(int x, int y) {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.scrollToGlobalPoint(blink::WebPoint(x, y));
 }
 
@@ skipping 26 matching lines @@
   accessibility_object_.updateLayoutAndCheckValidity();
   return BoundsForObject(accessibility_object_).height;
 }
 
 int WebAXObjectProxy::WordStart(int character_index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   if (accessibility_object_.role() != blink::WebAXRoleStaticText)
     return -1;
 
   int word_start = 0, word_end = 0;
-  GetBoundariesForOneWord(accessibility_object_, character_index,
-                          word_start, word_end);
+  GetBoundariesForOneWord(accessibility_object_, character_index, word_start,
+                          word_end);
   return word_start;
 }
 
 int WebAXObjectProxy::WordEnd(int character_index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   if (accessibility_object_.role() != blink::WebAXRoleStaticText)
     return -1;
 
   int word_start = 0, word_end = 0;
-  GetBoundariesForOneWord(accessibility_object_, character_index,
-                          word_start, word_end);
+  GetBoundariesForOneWord(accessibility_object_, character_index, word_start,
+                          word_end);
   return word_end;
 }
 
 v8::Local<v8::Object> WebAXObjectProxy::NextOnLine() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject obj = accessibility_object_.nextOnLine();
   if (obj.isNull())
     return v8::Local<v8::Object>();
 
   return factory_->GetOrCreate(obj);
@@ skipping 18 matching lines @@
 std::string WebAXObjectProxy::Name() {
   accessibility_object_.updateLayoutAndCheckValidity();
   return accessibility_object_.name().utf8();
 }
 
 std::string WebAXObjectProxy::NameFrom() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXNameFrom nameFrom = blink::WebAXNameFromUninitialized;
   blink::WebVector<blink::WebAXObject> nameObjects;
   accessibility_object_.name(nameFrom, nameObjects);
-  switch(nameFrom) {
+  switch (nameFrom) {
     case blink::WebAXNameFromUninitialized:
       return "";
     case blink::WebAXNameFromAttribute:
       return "attribute";
     case blink::WebAXNameFromCaption:
       return "caption";
     case blink::WebAXNameFromContents:
       return "contents";
     case blink::WebAXNameFromPlaceholder:
       return "placeholder";
@@ skipping 27 matching lines @@
   return factory_->GetOrCreate(nameObjects[index]);
 }
 
 std::string WebAXObjectProxy::Description() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXNameFrom nameFrom;
   blink::WebVector<blink::WebAXObject> nameObjects;
   accessibility_object_.name(nameFrom, nameObjects);
   blink::WebAXDescriptionFrom descriptionFrom;
   blink::WebVector<blink::WebAXObject> descriptionObjects;
-  return accessibility_object_.description(
-      nameFrom, descriptionFrom, descriptionObjects).utf8();
+  return accessibility_object_
+      .description(nameFrom, descriptionFrom, descriptionObjects)
+      .utf8();
 }
 
 std::string WebAXObjectProxy::DescriptionFrom() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXNameFrom nameFrom;
   blink::WebVector<blink::WebAXObject> nameObjects;
   accessibility_object_.name(nameFrom, nameObjects);
   blink::WebAXDescriptionFrom descriptionFrom =
       blink::WebAXDescriptionFromUninitialized;
   blink::WebVector<blink::WebAXObject> descriptionObjects;
-  accessibility_object_.description(
-      nameFrom, descriptionFrom, descriptionObjects);
-  switch(descriptionFrom) {
+  accessibility_object_.description(nameFrom, descriptionFrom,
+                                    descriptionObjects);
+  switch (descriptionFrom) {
     case blink::WebAXDescriptionFromUninitialized:
       return "";
     case blink::WebAXDescriptionFromAttribute:
       return "attribute";
     case blink::WebAXDescriptionFromContents:
       return "contents";
     case blink::WebAXDescriptionFromRelatedElement:
       return "relatedElement";
   }
 
@@ skipping 14 matching lines @@
   return GetMisspellings(accessibility_object_).size();
 }
 
 int WebAXObjectProxy::DescriptionElementCount() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXNameFrom nameFrom;
   blink::WebVector<blink::WebAXObject> nameObjects;
   accessibility_object_.name(nameFrom, nameObjects);
   blink::WebAXDescriptionFrom descriptionFrom;
   blink::WebVector<blink::WebAXObject> descriptionObjects;
-  accessibility_object_.description(
-      nameFrom, descriptionFrom, descriptionObjects);
+  accessibility_object_.description(nameFrom, descriptionFrom,
+                                    descriptionObjects);
   return static_cast<int>(descriptionObjects.size());
 }
 
 v8::Local<v8::Object> WebAXObjectProxy::DescriptionElementAtIndex(
     unsigned index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXNameFrom nameFrom;
   blink::WebVector<blink::WebAXObject> nameObjects;
   accessibility_object_.name(nameFrom, nameObjects);
   blink::WebAXDescriptionFrom descriptionFrom;
   blink::WebVector<blink::WebAXObject> descriptionObjects;
-  accessibility_object_.description(
-      nameFrom, descriptionFrom, descriptionObjects);
+  accessibility_object_.description(nameFrom, descriptionFrom,
+                                    descriptionObjects);
   if (index >= descriptionObjects.size())
     return v8::Local<v8::Object>();
   return factory_->GetOrCreate(descriptionObjects[index]);
 }
 
 v8::Local<v8::Object> WebAXObjectProxy::OffsetContainer() {
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject container;
   blink::WebFloatRect bounds;
   SkMatrix44 matrix;
@@ skipping 40 matching lines @@
 bool WebAXObjectProxy::HasNonIdentityTransform() {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject container;
   blink::WebFloatRect bounds;
   SkMatrix44 matrix;
   accessibility_object_.getRelativeBounds(container, bounds, matrix);
   return !matrix.isIdentity();
 }
 
-RootWebAXObjectProxy::RootWebAXObjectProxy(
-    const blink::WebAXObject &object, Factory *factory)
-    : WebAXObjectProxy(object, factory) {
-}
+RootWebAXObjectProxy::RootWebAXObjectProxy(const blink::WebAXObject& object,
+                                           Factory* factory)
+    : WebAXObjectProxy(object, factory) {}
 
 v8::Local<v8::Object> RootWebAXObjectProxy::GetChildAtIndex(unsigned index) {
   if (index)
     return v8::Local<v8::Object>();
 
   return factory()->GetOrCreate(accessibility_object());
 }
 
 bool RootWebAXObjectProxy::IsRoot() const {
   return true;
 }
 
 WebAXObjectProxyList::WebAXObjectProxyList()
-    : elements_(blink::mainThreadIsolate()) {
-}
+    : elements_(blink::mainThreadIsolate()) {}
 
 WebAXObjectProxyList::~WebAXObjectProxyList() {
   Clear();
 }
 
 void WebAXObjectProxyList::Clear() {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   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);
+    bool result =
+        gin::ConvertFromV8(isolate, elements_.Get(i), &unwrapped_object);
     DCHECK(result);
     DCHECK(unwrapped_object);
     unwrapped_object->Reset();
   }
   elements_.Clear();
 }
 
 v8::Local<v8::Object> WebAXObjectProxyList::GetOrCreate(
     const blink::WebAXObject& object) {
   if (object.isNull())
     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);
+    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::Local<v8::Value> value_handle = gin::CreateHandle(
-      isolate, new WebAXObjectProxy(object, this)).ToV8();
+  v8::Local<v8::Value> value_handle =
+      gin::CreateHandle(isolate, new WebAXObjectProxy(object, this)).ToV8();
   if (value_handle.IsEmpty())
     return v8::Local<v8::Object>();
   v8::Local<v8::Object> handle = value_handle->ToObject(isolate);
   elements_.Append(handle);
   return handle;
 }
 
 }  // namespace test_runner