Rename WebKit namespace to blink (part 3)

content/browser/accessibility/browser_accessibility.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/browser/accessibility/browser_accessibility.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 26 matching lines @@
       renderer_id_(0),
       role_(0),
       state_(0),
       instance_active_(false) {
 }
 
 BrowserAccessibility::~BrowserAccessibility() {
 }
 
 bool BrowserAccessibility::PlatformIsLeaf() const {
-  return role_ == WebKit::WebAXRoleStaticText || child_count() == 0;
+  return role_ == blink::WebAXRoleStaticText || child_count() == 0;
 }
 
 uint32 BrowserAccessibility::PlatformChildCount() const {
   return PlatformIsLeaf() ? 0 : children_.size();
 }
 
 void BrowserAccessibility::DetachTree(
     std::vector<BrowserAccessibility*>* nodes) {
   nodes->push_back(this);
   for (size_t i = 0; i < children_.size(); ++i)
@@ skipping 86 matching lines @@
 }
 
 gfx::Rect BrowserAccessibility::GetLocalBoundsRect() const {
   gfx::Rect bounds = location_;
 
   // Walk up the parent chain. Every time we encounter a Web Area, offset
   // based on the scroll bars and then offset based on the origin of that
   // nested web area.
   BrowserAccessibility* parent = parent_;
   bool need_to_offset_web_area =
-      (role_ == WebKit::WebAXRoleWebArea ||
-       role_ == WebKit::WebAXRoleRootWebArea);
+      (role_ == blink::WebAXRoleWebArea ||
+       role_ == blink::WebAXRoleRootWebArea);
   while (parent) {
     if (need_to_offset_web_area &&
         parent->location().width() > 0 &&
         parent->location().height() > 0) {
       bounds.Offset(parent->location().x(), parent->location().y());
       need_to_offset_web_area = false;
     }
 
     // On some platforms, we don't want to take the root scroll offsets
     // into account.
-    if (parent->role() == WebKit::WebAXRoleRootWebArea &&
+    if (parent->role() == blink::WebAXRoleRootWebArea &&
         !manager()->UseRootScrollOffsetsWhenComputingBounds()) {
       break;
     }
 
-    if (parent->role() == WebKit::WebAXRoleWebArea ||
-        parent->role() == WebKit::WebAXRoleRootWebArea) {
+    if (parent->role() == blink::WebAXRoleWebArea ||
+        parent->role() == blink::WebAXRoleRootWebArea) {
       int sx = 0;
       int sy = 0;
       if (parent->GetIntAttribute(AccessibilityNodeData::ATTR_SCROLL_X, &sx) &&
           parent->GetIntAttribute(AccessibilityNodeData::ATTR_SCROLL_Y, &sy)) {
         bounds.Offset(-sx, -sy);
       }
       need_to_offset_web_area = true;
     }
     parent = parent->parent();
   }
 
   return bounds;
 }
 
 gfx::Rect BrowserAccessibility::GetGlobalBoundsRect() const {
   gfx::Rect bounds = GetLocalBoundsRect();
 
   // Adjust the bounds by the top left corner of the containing view's bounds
   // in screen coordinates.
   bounds.Offset(manager_->GetViewBounds().OffsetFromOrigin());
 
   return bounds;
 }
 
 gfx::Rect BrowserAccessibility::GetLocalBoundsForRange(int start, int len)
     const {
-  DCHECK_EQ(role_, WebKit::WebAXRoleStaticText);
+  DCHECK_EQ(role_, blink::WebAXRoleStaticText);
   int end = start + len;
   int child_start = 0;
   int child_end = 0;
 
   gfx::Rect bounds;
   for (size_t i = 0; i < children_.size() && child_end < start + len; ++i) {
     BrowserAccessibility* child = children_[i];
-    DCHECK_EQ(child->role(), WebKit::WebAXRoleInlineTextBox);
+    DCHECK_EQ(child->role(), blink::WebAXRoleInlineTextBox);
     std::string child_text;
     child->GetStringAttribute(AccessibilityNodeData::ATTR_VALUE, &child_text);
     int child_len = static_cast<int>(child_text.size());
     child_start = child_end;
     child_end += child_len;
 
     if (child_end < start)
       continue;
 
     int overlap_start = std::max(start, child_start);
     int overlap_end = std::min(end, child_end);
 
     int local_start = overlap_start - child_start;
     int local_end = overlap_end - child_start;
 
     gfx::Rect child_rect = child->location();
     int text_direction = child->GetIntAttribute(
         AccessibilityNodeData::ATTR_TEXT_DIRECTION);
     const std::vector<int32>& character_offsets = child->GetIntListAttribute(
         AccessibilityNodeData::ATTR_CHARACTER_OFFSETS);
     int start_pixel_offset =
         local_start > 0 ? character_offsets[local_start - 1] : 0;
     int end_pixel_offset =
         local_end > 0 ? character_offsets[local_end - 1] : 0;
 
     gfx::Rect child_overlap_rect;
     switch (text_direction) {
-      case WebKit::WebAXTextDirectionLR: {
+      case blink::WebAXTextDirectionLR: {
         int left = child_rect.x() + start_pixel_offset;
         int right = child_rect.x() + end_pixel_offset;
         child_overlap_rect = gfx::Rect(left, child_rect.y(),
                                        right - left, child_rect.height());
         break;
       }
-      case WebKit::WebAXTextDirectionRL: {
+      case blink::WebAXTextDirectionRL: {
         int right = child_rect.right() - start_pixel_offset;
         int left = child_rect.right() - end_pixel_offset;
         child_overlap_rect = gfx::Rect(left, child_rect.y(),
                                        right - left, child_rect.height());
         break;
       }
-      case WebKit::WebAXTextDirectionTB: {
+      case blink::WebAXTextDirectionTB: {
         int top = child_rect.y() + start_pixel_offset;
         int bottom = child_rect.y() + end_pixel_offset;
         child_overlap_rect = gfx::Rect(child_rect.x(), top,
                                        child_rect.width(), bottom - top);
         break;
       }
-      case WebKit::WebAXTextDirectionBT: {
+      case blink::WebAXTextDirectionBT: {
         int bottom = child_rect.bottom() - start_pixel_offset;
         int top = child_rect.bottom() - end_pixel_offset;
         child_overlap_rect = gfx::Rect(child_rect.x(), top,
                                        child_rect.width(), bottom - top);
         break;
       }
       default:
         NOTREACHED();
     }
 
@@ skipping 36 matching lines @@
     (*iter)->Destroy();
   }
   children_.clear();
 
   // Allow the object to fire a TextRemoved notification.
   name_.clear();
   value_.clear();
   PostInitialize();
 
   manager_->NotifyAccessibilityEvent(
-      WebKit::WebAXEventHide, this);
+      blink::WebAXEventHide, this);
 
   instance_active_ = false;
   manager_->RemoveNode(this);
   NativeReleaseReference();
 }
 
 void BrowserAccessibility::NativeReleaseReference() {
   delete this;
 }
 
@@ skipping 224 matching lines @@
 
   if (EqualsASCII(value, "true"))
     return true;
 
   if (EqualsASCII(value, "mixed"))
     *is_mixed = true;
 
   return false;  // Not set
 }
 
-bool BrowserAccessibility::HasState(WebKit::WebAXState state_enum) const {
+bool BrowserAccessibility::HasState(blink::WebAXState state_enum) const {
   return (state_ >> state_enum) & 1;
 }
 
 bool BrowserAccessibility::IsEditableText() const {
   // These roles don't have readonly set, but they're not editable text.
-  if (role_ == WebKit::WebAXRoleScrollArea ||
-      role_ == WebKit::WebAXRoleColumn ||
-      role_ == WebKit::WebAXRoleTableHeaderContainer) {
+  if (role_ == blink::WebAXRoleScrollArea ||
+      role_ == blink::WebAXRoleColumn ||
+      role_ == blink::WebAXRoleTableHeaderContainer) {
     return false;
   }
 
   // Note: WebAXStateReadonly being false means it's either a text control,
   // or contenteditable. We also check for editable text roles to cover
   // another element that has role=textbox set on it.
-  return (!HasState(WebKit::WebAXStateReadonly) ||
-          role_ == WebKit::WebAXRoleTextField ||
-          role_ == WebKit::WebAXRoleTextArea);
+  return (!HasState(blink::WebAXStateReadonly) ||
+          role_ == blink::WebAXRoleTextField ||
+          role_ == blink::WebAXRoleTextArea);
 }
 
 std::string BrowserAccessibility::GetTextRecursive() const {
   if (!name_.empty()) {
     return name_;
   }
 
   std::string result;
   for (size_t i = 0; i < children_.size(); ++i)
     result += children_[i]->GetTextRecursive();
   return result;
 }
 
 }  // namespace content