Rename WebKit namespace to blink (part 3)

content/browser/accessibility/browser_accessibility_win.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_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include "base/strings/string_number_conversions.h"
@@ skipping 582 matching lines @@
 STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(BSTR* help_file,
                                                        VARIANT var_id,
                                                        LONG* topic_id) {
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
   if (!instance_active_)
     return E_FAIL;
 
-  if (role_ != WebKit::WebAXRoleListBox)
+  if (role_ != blink::WebAXRoleListBox)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
   for (size_t i = 0; i < children_.size(); ++i) {
-    if (children_[i]->HasState(WebKit::WebAXStateSelected))
+    if (children_[i]->HasState(blink::WebAXStateSelected))
       ++selected_count;
   }
 
   if (selected_count == 0) {
     selected->vt = VT_EMPTY;
     return S_OK;
   }
 
   if (selected_count == 1) {
     for (size_t i = 0; i < children_.size(); ++i) {
-      if (children_[i]->HasState(WebKit::WebAXStateSelected)) {
+      if (children_[i]->HasState(blink::WebAXStateSelected)) {
         selected->vt = VT_DISPATCH;
         selected->pdispVal =
             children_[i]->ToBrowserAccessibilityWin()->NewReference();
         return S_OK;
       }
     }
   }
 
   // Multiple items are selected.
   base::win::EnumVariant* enum_variant =
       new base::win::EnumVariant(selected_count);
   enum_variant->AddRef();
   unsigned long index = 0;
   for (size_t i = 0; i < children_.size(); ++i) {
-    if (children_[i]->HasState(WebKit::WebAXStateSelected)) {
+    if (children_[i]->HasState(blink::WebAXStateSelected)) {
       enum_variant->ItemAt(index)->vt = VT_DISPATCH;
       enum_variant->ItemAt(index)->pdispVal =
         children_[i]->ToBrowserAccessibilityWin()->NewReference();
       ++index;
     }
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
@@ skipping 220 matching lines @@
 STDMETHODIMP BrowserAccessibilityWin::get_groupPosition(
     LONG* group_level,
     LONG* similar_items_in_group,
     LONG* position_in_group) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!group_level || !similar_items_in_group || !position_in_group)
     return E_INVALIDARG;
 
-  if (role_ == WebKit::WebAXRoleListBoxOption &&
+  if (role_ == blink::WebAXRoleListBoxOption &&
       parent_ &&
-      parent_->role() == WebKit::WebAXRoleListBox) {
+      parent_->role() == blink::WebAXRoleListBox) {
     *group_level = 0;
     *similar_items_in_group = parent_->PlatformChildCount();
     *position_in_group = index_in_parent_ + 1;
     return S_OK;
   }
 
   return E_NOTIMPL;
 }
 
 //
@@ skipping 238 matching lines @@
 
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
   const std::vector<int32>& cell_ids = GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
         manager_->GetFromRendererID(cell_id));
-    if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader) {
+    if (cell && cell->role_ == blink::WebAXRoleColumnHeader) {
       string16 cell_name = cell->GetString16Attribute(
           AccessibilityNodeData::ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       return cell->GetStringAttributeAsBstr(
           AccessibilityNodeData::ATTR_DESCRIPTION, description);
     }
@@ skipping 166 matching lines @@
 
   if (row < 0 || row >= rows)
     return E_INVALIDARG;
 
   const std::vector<int32>& cell_ids = GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == WebKit::WebAXRoleRowHeader) {
+    if (cell && cell->role_ == blink::WebAXRoleRowHeader) {
       string16 cell_name = cell->GetString16Attribute(
           AccessibilityNodeData::ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       return cell->GetStringAttributeAsBstr(
           AccessibilityNodeData::ATTR_DESCRIPTION, description);
     }
@@ skipping 302 matching lines @@
 
   *n_column_header_cells = 0;
 
   int column;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
     return S_FALSE;
   }
 
   BrowserAccessibility* table = parent();
-  while (table && table->role() != WebKit::WebAXRoleTable)
+  while (table && table->role() != blink::WebAXRoleTable)
     table = table->parent();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   int columns;
   int rows;
   if (!table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
   const std::vector<int32>& cell_ids = table->GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
 
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader)
+    if (cell && cell->role_ == blink::WebAXRoleColumnHeader)
       (*n_column_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_column_header_cells) * sizeof(cell_accessibles[0])));
   int index = 0;
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader) {
+    if (cell && cell->role_ == blink::WebAXRoleColumnHeader) {
       (*cell_accessibles)[index] =
           static_cast<IAccessible*>(cell->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
@@ skipping 42 matching lines @@
 
   *n_row_header_cells = 0;
 
   int row;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row)) {
     return S_FALSE;
   }
 
   BrowserAccessibility* table = parent();
-  while (table && table->role() != WebKit::WebAXRoleTable)
+  while (table && table->role() != blink::WebAXRoleTable)
     table = table->parent();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   int columns;
   int rows;
   if (!table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
   const std::vector<int32>& cell_ids = table->GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
 
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == WebKit::WebAXRoleRowHeader)
+    if (cell && cell->role_ == blink::WebAXRoleRowHeader)
       (*n_row_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_row_header_cells) * sizeof(cell_accessibles[0])));
   int index = 0;
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == WebKit::WebAXRoleRowHeader) {
+    if (cell && cell->role_ == blink::WebAXRoleRowHeader) {
       (*cell_accessibles)[index] =
           static_cast<IAccessible*>(cell->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
@@ skipping 68 matching lines @@
   if (!table)
     return E_INVALIDARG;
 
 
   int row;
   int column;
   GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row);
   GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column);
 
   BrowserAccessibility* find_table = parent();
-  while (find_table && find_table->role() != WebKit::WebAXRoleTable)
+  while (find_table && find_table->role() != blink::WebAXRoleTable)
     find_table = find_table->parent();
   if (!find_table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   *table = static_cast<IAccessibleTable*>(
       find_table->ToBrowserAccessibilityWin()->NewReference());
 
   return S_OK;
@@ skipping 15 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   *offset = 0;
-  if (role_ == WebKit::WebAXRoleTextField ||
-      role_ == WebKit::WebAXRoleTextArea) {
+  if (role_ == blink::WebAXRoleTextField ||
+      role_ == blink::WebAXRoleTextArea) {
     int sel_start = 0;
     if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
                         &sel_start))
       *offset = sel_start;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelections(LONG* n_selections) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!n_selections)
     return E_INVALIDARG;
 
   *n_selections = 0;
-  if (role_ == WebKit::WebAXRoleTextField ||
-      role_ == WebKit::WebAXRoleTextArea) {
+  if (role_ == blink::WebAXRoleTextField ||
+      role_ == blink::WebAXRoleTextArea) {
     int sel_start = 0;
     int sel_end = 0;
     if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
                         &sel_start) &&
         GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end) &&
         sel_start != sel_end)
       *n_selections = 1;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selection(LONG selection_index,
                                                     LONG* start_offset,
                                                     LONG* end_offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!start_offset || !end_offset || selection_index != 0)
     return E_INVALIDARG;
 
   *start_offset = 0;
   *end_offset = 0;
-  if (role_ == WebKit::WebAXRoleTextField ||
-      role_ == WebKit::WebAXRoleTextArea) {
+  if (role_ == blink::WebAXRoleTextField ||
+      role_ == blink::WebAXRoleTextArea) {
     int sel_start = 0;
     int sel_end = 0;
     if (GetIntAttribute(
             AccessibilityNodeData::ATTR_TEXT_SEL_START, &sel_start) &&
         GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end)) {
       *start_offset = sel_start;
       *end_offset = sel_end;
     }
   }
 
@@ skipping 832 matching lines @@
 
   // Expose the "display" and "tag" attributes.
   StringAttributeToIA2(AccessibilityNodeData::ATTR_DISPLAY, "display");
   StringAttributeToIA2(AccessibilityNodeData::ATTR_HTML_TAG, "tag");
   StringAttributeToIA2(AccessibilityNodeData::ATTR_ROLE, "xml-roles");
 
   // Expose "level" attribute for headings, trees, etc.
   IntAttributeToIA2(AccessibilityNodeData::ATTR_HIERARCHICAL_LEVEL, "level");
 
   // Expose the set size and position in set for listbox options.
-  if (role_ == WebKit::WebAXRoleListBoxOption &&
+  if (role_ == blink::WebAXRoleListBoxOption &&
       parent_ &&
-      parent_->role() == WebKit::WebAXRoleListBox) {
+      parent_->role() == blink::WebAXRoleListBox) {
     ia2_attributes_.push_back(
         L"setsize:" + base::IntToString16(parent_->PlatformChildCount()));
     ia2_attributes_.push_back(
         L"setsize:" + base::IntToString16(index_in_parent_ + 1));
   }
 
   if (ia_role_ == ROLE_SYSTEM_CHECKBUTTON ||
       ia_role_ == ROLE_SYSTEM_RADIOBUTTON ||
       ia2_role_ == IA2_ROLE_TOGGLE_BUTTON) {
     ia2_attributes_.push_back(L"checkable:true");
@@ skipping 18 matching lines @@
   // Expose slider value.
   if (ia_role_ == ROLE_SYSTEM_PROGRESSBAR ||
       ia_role_ == ROLE_SYSTEM_SCROLLBAR ||
       ia_role_ == ROLE_SYSTEM_SLIDER) {
     ia2_attributes_.push_back(L"valuetext:" + GetValueText());
   }
 
   // Expose table cell index.
   if (ia_role_ == ROLE_SYSTEM_CELL) {
     BrowserAccessibility* table = parent();
-    while (table && table->role() != WebKit::WebAXRoleTable)
+    while (table && table->role() != blink::WebAXRoleTable)
       table = table->parent();
     if (table) {
       const std::vector<int32>& unique_cell_ids = table->GetIntListAttribute(
           AccessibilityNodeData::ATTR_UNIQUE_CELL_IDS);
       for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
         if (unique_cell_ids[i] == renderer_id_) {
           ia2_attributes_.push_back(
               string16(L"table-cell-index:") + base::IntToString16(i));
         }
       }
@@ skipping 49 matching lines @@
     description = help;
     help.clear();
   }
   if (!description.empty() && name_.empty() && !title_elem_id) {
     name_ = description;
     description.clear();
   }
 
   // If it's a text field, also consider the placeholder.
   std::string placeholder;
-  if (role_ == WebKit::WebAXRoleTextField &&
-      HasState(WebKit::WebAXStateFocusable) &&
+  if (role_ == blink::WebAXRoleTextField &&
+      HasState(blink::WebAXStateFocusable) &&
       GetHtmlAttribute("placeholder", &placeholder)) {
     if (name_.empty() && !title_elem_id) {
       name_ = placeholder;
     } else if (description.empty()) {
       description = placeholder;
     }
   }
 
   SetStringAttribute(AccessibilityNodeData::ATTR_DESCRIPTION, description);
   SetStringAttribute(AccessibilityNodeData::ATTR_HELP, help);
 
   // On Windows, the value of a document should be its url.
-  if (role_ == WebKit::WebAXRoleRootWebArea ||
-      role_ == WebKit::WebAXRoleWebArea) {
+  if (role_ == blink::WebAXRoleRootWebArea ||
+      role_ == blink::WebAXRoleWebArea) {
     GetStringAttribute(AccessibilityNodeData::ATTR_DOC_URL, &value_);
   }
 
   // For certain roles (listbox option, static text, and list marker)
   // WebKit stores the main accessible text in the "value" - swap it so
   // that it's the "name".
   if (name_.empty() &&
-      (role_ == WebKit::WebAXRoleListBoxOption ||
-       role_ == WebKit::WebAXRoleStaticText ||
-       role_ == WebKit::WebAXRoleListMarker)) {
+      (role_ == blink::WebAXRoleListBoxOption ||
+       role_ == blink::WebAXRoleStaticText ||
+       role_ == blink::WebAXRoleListMarker)) {
     name_.swap(value_);
   }
 
   // If this doesn't have a value and is linked then set its value to the url
   // attribute. This allows screen readers to read an empty link's destination.
   if (value_.empty() && (ia_state_ & STATE_SYSTEM_LINKED))
     GetStringAttribute(AccessibilityNodeData::ATTR_URL, &value_);
 
   // Clear any old relationships between this node and other nodes.
   for (size_t i = 0; i < relations_.size(); ++i)
@@ skipping 16 matching lines @@
 
 void BrowserAccessibilityWin::PostInitialize() {
   BrowserAccessibility::PostInitialize();
 
   // Construct the hypertext for this node.
   hyperlink_offset_to_index_.clear();
   hyperlinks_.clear();
   hypertext_.clear();
   for (unsigned int i = 0; i < PlatformChildCount(); ++i) {
     BrowserAccessibility* child = PlatformGetChild(i);
-    if (child->role() == WebKit::WebAXRoleStaticText) {
+    if (child->role() == blink::WebAXRoleStaticText) {
       hypertext_ += UTF8ToUTF16(child->name());
     } else {
       hyperlink_offset_to_index_[hypertext_.size()] = hyperlinks_.size();
       hypertext_ += kEmbeddedCharacter;
       hyperlinks_.push_back(i);
     }
   }
   DCHECK_EQ(hyperlink_offset_to_index_.size(), hyperlinks_.size());
 
   // Fire an event when an alert first appears.
-  if (role_ == WebKit::WebAXRoleAlert && first_time_)
-    manager_->NotifyAccessibilityEvent(WebKit::WebAXEventAlert, this);
+  if (role_ == blink::WebAXRoleAlert && first_time_)
+    manager_->NotifyAccessibilityEvent(blink::WebAXEventAlert, this);
 
   // Fire events if text has changed.
   string16 text = TextForIAccessibleText();
   if (previous_text_ != text) {
     if (!previous_text_.empty() && !text.empty()) {
       manager_->NotifyAccessibilityEvent(
-          WebKit::WebAXEventShow, this);
+          blink::WebAXEventShow, this);
     }
 
     // TODO(dmazzoni): Look into HIDE events, too.
 
     old_text_ = previous_text_;
     previous_text_ = text;
   }
 
   // Fire events if the state has changed.
   if (!first_time_ && ia_state_ != old_ia_state_) {
     BrowserAccessibilityManagerWin* manager =
         manager_->ToBrowserAccessibilityManagerWin();
 
     // Normally focus events are handled elsewhere, however
     // focus for managed descendants is platform-specific.
     // Fire a focus event if the focused descendant in a multi-select
     // list box changes.
-    if (role_ == WebKit::WebAXRoleListBoxOption &&
+    if (role_ == blink::WebAXRoleListBoxOption &&
         (ia_state_ & STATE_SYSTEM_FOCUSABLE) &&
         (ia_state_ & STATE_SYSTEM_SELECTABLE) &&
         (ia_state_ & STATE_SYSTEM_FOCUSED) &&
         !(old_ia_state_ & STATE_SYSTEM_FOCUSED)) {
       manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_FOCUS, unique_id_win());
     }
 
     if ((ia_state_ & STATE_SYSTEM_SELECTED) &&
         !(old_ia_state_ & STATE_SYSTEM_SELECTED)) {
       manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_SELECTIONADD,
@@ skipping 100 matching lines @@
   if (value.empty() &&
       GetFloatAttribute(AccessibilityNodeData::ATTR_VALUE_FOR_RANGE, &fval)) {
     value = UTF8ToUTF16(base::DoubleToString(fval));
   }
   return value;
 }
 
 string16 BrowserAccessibilityWin::TextForIAccessibleText() {
   if (IsEditableText())
     return UTF8ToUTF16(value_);
-  return (role_ == WebKit::WebAXRoleStaticText) ?
+  return (role_ == blink::WebAXRoleStaticText) ?
       UTF8ToUTF16(name_) : hypertext_;
 }
 
 void BrowserAccessibilityWin::HandleSpecialTextOffset(const string16& text,
                                                       LONG* offset) {
   if (*offset == IA2_TEXT_OFFSET_LENGTH)
     *offset = static_cast<LONG>(text.size());
   else if (*offset == IA2_TEXT_OFFSET_CARET)
     get_caretOffset(offset);
 }
@@ skipping 29 matching lines @@
 BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromRendererID(
     int32 renderer_id) {
   return manager_->GetFromRendererID(renderer_id)->ToBrowserAccessibilityWin();
 }
 
 void BrowserAccessibilityWin::InitRoleAndState() {
   ia_state_ = 0;
   ia2_state_ = IA2_STATE_OPAQUE;
   ia2_attributes_.clear();
 
-  if (HasState(WebKit::WebAXStateBusy))
+  if (HasState(blink::WebAXStateBusy))
     ia_state_ |= STATE_SYSTEM_BUSY;
-  if (HasState(WebKit::WebAXStateChecked))
+  if (HasState(blink::WebAXStateChecked))
     ia_state_ |= STATE_SYSTEM_CHECKED;
-  if (HasState(WebKit::WebAXStateCollapsed))
+  if (HasState(blink::WebAXStateCollapsed))
     ia_state_ |= STATE_SYSTEM_COLLAPSED;
-  if (HasState(WebKit::WebAXStateExpanded))
+  if (HasState(blink::WebAXStateExpanded))
     ia_state_ |= STATE_SYSTEM_EXPANDED;
-  if (HasState(WebKit::WebAXStateFocusable))
+  if (HasState(blink::WebAXStateFocusable))
     ia_state_ |= STATE_SYSTEM_FOCUSABLE;
-  if (HasState(WebKit::WebAXStateHaspopup))
+  if (HasState(blink::WebAXStateHaspopup))
     ia_state_ |= STATE_SYSTEM_HASPOPUP;
-  if (HasState(WebKit::WebAXStateHovered))
+  if (HasState(blink::WebAXStateHovered))
     ia_state_ |= STATE_SYSTEM_HOTTRACKED;
-  if (HasState(WebKit::WebAXStateIndeterminate))
+  if (HasState(blink::WebAXStateIndeterminate))
     ia_state_ |= STATE_SYSTEM_INDETERMINATE;
-  if (HasState(WebKit::WebAXStateInvisible))
+  if (HasState(blink::WebAXStateInvisible))
     ia_state_ |= STATE_SYSTEM_INVISIBLE;
-  if (HasState(WebKit::WebAXStateLinked))
+  if (HasState(blink::WebAXStateLinked))
     ia_state_ |= STATE_SYSTEM_LINKED;
-  if (HasState(WebKit::WebAXStateMultiselectable)) {
+  if (HasState(blink::WebAXStateMultiselectable)) {
     ia_state_ |= STATE_SYSTEM_EXTSELECTABLE;
     ia_state_ |= STATE_SYSTEM_MULTISELECTABLE;
   }
   // TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect.
-  if (HasState(WebKit::WebAXStateOffscreen))
+  if (HasState(blink::WebAXStateOffscreen))
     ia_state_ |= STATE_SYSTEM_OFFSCREEN;
-  if (HasState(WebKit::WebAXStatePressed))
+  if (HasState(blink::WebAXStatePressed))
     ia_state_ |= STATE_SYSTEM_PRESSED;
-  if (HasState(WebKit::WebAXStateProtected))
+  if (HasState(blink::WebAXStateProtected))
     ia_state_ |= STATE_SYSTEM_PROTECTED;
-  if (HasState(WebKit::WebAXStateRequired))
+  if (HasState(blink::WebAXStateRequired))
     ia2_state_ |= IA2_STATE_REQUIRED;
-  if (HasState(WebKit::WebAXStateSelectable))
+  if (HasState(blink::WebAXStateSelectable))
     ia_state_ |= STATE_SYSTEM_SELECTABLE;
-  if (HasState(WebKit::WebAXStateSelected))
+  if (HasState(blink::WebAXStateSelected))
     ia_state_ |= STATE_SYSTEM_SELECTED;
-  if (HasState(WebKit::WebAXStateVisited))
+  if (HasState(blink::WebAXStateVisited))
     ia_state_ |= STATE_SYSTEM_TRAVERSED;
-  if (!HasState(WebKit::WebAXStateEnabled))
+  if (!HasState(blink::WebAXStateEnabled))
     ia_state_ |= STATE_SYSTEM_UNAVAILABLE;
-  if (HasState(WebKit::WebAXStateVertical)) {
+  if (HasState(blink::WebAXStateVertical)) {
     ia2_state_ |= IA2_STATE_VERTICAL;
   } else {
     ia2_state_ |= IA2_STATE_HORIZONTAL;
   }
-  if (HasState(WebKit::WebAXStateVisited))
+  if (HasState(blink::WebAXStateVisited))
     ia_state_ |= STATE_SYSTEM_TRAVERSED;
 
   // WebKit marks everything as readonly unless it's editable text, so if it's
   // not readonly, mark it as editable now. The final computation of the
   // READONLY state for MSAA is below, after the switch.
-  if (!HasState(WebKit::WebAXStateReadonly))
+  if (!HasState(blink::WebAXStateReadonly))
     ia2_state_ |= IA2_STATE_EDITABLE;
 
   string16 invalid;
   if (GetHtmlAttribute("aria-invalid", &invalid))
     ia2_state_ |= IA2_STATE_INVALID_ENTRY;
 
   if (GetBoolAttribute(AccessibilityNodeData::ATTR_BUTTON_MIXED))
     ia_state_ |= STATE_SYSTEM_MIXED;
 
   if (GetBoolAttribute(AccessibilityNodeData::ATTR_CAN_SET_VALUE))
     ia2_state_ |= IA2_STATE_EDITABLE;
 
   string16 html_tag = GetString16Attribute(
       AccessibilityNodeData::ATTR_HTML_TAG);
   ia_role_ = 0;
   ia2_role_ = 0;
   switch (role_) {
-    case WebKit::WebAXRoleAlert:
+    case blink::WebAXRoleAlert:
       ia_role_ = ROLE_SYSTEM_ALERT;
       break;
-    case WebKit::WebAXRoleAlertDialog:
+    case blink::WebAXRoleAlertDialog:
       ia_role_ = ROLE_SYSTEM_DIALOG;
       break;
-    case WebKit::WebAXRoleApplication:
+    case blink::WebAXRoleApplication:
       ia_role_ = ROLE_SYSTEM_APPLICATION;
       break;
-    case WebKit::WebAXRoleArticle:
+    case blink::WebAXRoleArticle:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleBusyIndicator:
+    case blink::WebAXRoleBusyIndicator:
       ia_role_ = ROLE_SYSTEM_ANIMATION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleButton:
+    case blink::WebAXRoleButton:
       ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
       bool is_aria_pressed_defined;
       bool is_mixed;
       if (GetAriaTristate("aria-pressed", &is_aria_pressed_defined, &is_mixed))
         ia_state_ |= STATE_SYSTEM_PRESSED;
       if (is_aria_pressed_defined)
         ia2_role_ = IA2_ROLE_TOGGLE_BUTTON;
       if (is_mixed)
         ia_state_ |= STATE_SYSTEM_MIXED;
       break;
-    case WebKit::WebAXRoleCanvas:
+    case blink::WebAXRoleCanvas:
       if (GetBoolAttribute(AccessibilityNodeData::ATTR_CANVAS_HAS_FALLBACK)) {
         role_name_ = L"canvas";
         ia2_role_ = IA2_ROLE_CANVAS;
       } else {
         ia_role_ = ROLE_SYSTEM_GRAPHIC;
       }
       break;
-    case WebKit::WebAXRoleCell:
+    case blink::WebAXRoleCell:
       ia_role_ = ROLE_SYSTEM_CELL;
       break;
-    case WebKit::WebAXRoleCheckBox:
+    case blink::WebAXRoleCheckBox:
       ia_role_ = ROLE_SYSTEM_CHECKBUTTON;
       break;
-    case WebKit::WebAXRoleColorWell:
+    case blink::WebAXRoleColorWell:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_COLOR_CHOOSER;
       break;
-    case WebKit::WebAXRoleColumn:
+    case blink::WebAXRoleColumn:
       ia_role_ = ROLE_SYSTEM_COLUMN;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleColumnHeader:
+    case blink::WebAXRoleColumnHeader:
       ia_role_ = ROLE_SYSTEM_COLUMNHEADER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleComboBox:
+    case blink::WebAXRoleComboBox:
       ia_role_ = ROLE_SYSTEM_COMBOBOX;
       break;
-    case WebKit::WebAXRoleDiv:
+    case blink::WebAXRoleDiv:
       role_name_ = L"div";
       ia2_role_ = IA2_ROLE_SECTION;
       break;
-    case WebKit::WebAXRoleDefinition:
+    case blink::WebAXRoleDefinition:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_PARAGRAPH;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleDescriptionListDetail:
+    case blink::WebAXRoleDescriptionListDetail:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_PARAGRAPH;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleDescriptionListTerm:
+    case blink::WebAXRoleDescriptionListTerm:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleDialog:
+    case blink::WebAXRoleDialog:
       ia_role_ = ROLE_SYSTEM_DIALOG;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleDisclosureTriangle:
+    case blink::WebAXRoleDisclosureTriangle:
       ia_role_ = ROLE_SYSTEM_OUTLINEBUTTON;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleDocument:
-    case WebKit::WebAXRoleRootWebArea:
-    case WebKit::WebAXRoleWebArea:
+    case blink::WebAXRoleDocument:
+    case blink::WebAXRoleRootWebArea:
+    case blink::WebAXRoleWebArea:
       ia_role_ = ROLE_SYSTEM_DOCUMENT;
       ia_state_ |= STATE_SYSTEM_READONLY;
       ia_state_ |= STATE_SYSTEM_FOCUSABLE;
       break;
-    case WebKit::WebAXRoleEditableText:
+    case blink::WebAXRoleEditableText:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_state_ |= IA2_STATE_SINGLE_LINE;
       ia2_state_ |= IA2_STATE_EDITABLE;
       break;
-    case WebKit::WebAXRoleForm:
+    case blink::WebAXRoleForm:
       role_name_ = L"form";
       ia2_role_ = IA2_ROLE_FORM;
       break;
-    case WebKit::WebAXRoleFooter:
+    case blink::WebAXRoleFooter:
       ia_role_ = IA2_ROLE_FOOTER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleGrid:
+    case blink::WebAXRoleGrid:
       ia_role_ = ROLE_SYSTEM_TABLE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleGroup: {
+    case blink::WebAXRoleGroup: {
       string16 aria_role = GetString16Attribute(
           AccessibilityNodeData::ATTR_ROLE);
       if (aria_role == L"group" || html_tag == L"fieldset") {
         ia_role_ = ROLE_SYSTEM_GROUPING;
       } else if (html_tag == L"li") {
         ia_role_ = ROLE_SYSTEM_LISTITEM;
       } else {
         if (html_tag.empty())
           role_name_ = L"div";
         else
           role_name_ = html_tag;
         ia2_role_ = IA2_ROLE_SECTION;
       }
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
     }
-    case WebKit::WebAXRoleGrowArea:
+    case blink::WebAXRoleGrowArea:
       ia_role_ = ROLE_SYSTEM_GRIP;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleHeading:
+    case blink::WebAXRoleHeading:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_HEADING;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleHorizontalRule:
+    case blink::WebAXRoleHorizontalRule:
       ia_role_ = ROLE_SYSTEM_SEPARATOR;
       break;
-    case WebKit::WebAXRoleImage:
+    case blink::WebAXRoleImage:
       ia_role_ = ROLE_SYSTEM_GRAPHIC;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleImageMap:
+    case blink::WebAXRoleImageMap:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_IMAGE_MAP;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleImageMapLink:
+    case blink::WebAXRoleImageMapLink:
       ia_role_ = ROLE_SYSTEM_LINK;
       ia_state_ |= STATE_SYSTEM_LINKED;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleLabel:
+    case blink::WebAXRoleLabel:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_role_ = IA2_ROLE_LABEL;
       break;
-    case WebKit::WebAXRoleBanner:
-    case WebKit::WebAXRoleComplementary:
-    case WebKit::WebAXRoleContentInfo:
-    case WebKit::WebAXRoleMain:
-    case WebKit::WebAXRoleNavigation:
-    case WebKit::WebAXRoleSearch:
+    case blink::WebAXRoleBanner:
+    case blink::WebAXRoleComplementary:
+    case blink::WebAXRoleContentInfo:
+    case blink::WebAXRoleMain:
+    case blink::WebAXRoleNavigation:
+    case blink::WebAXRoleSearch:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleLink:
+    case blink::WebAXRoleLink:
       ia_role_ = ROLE_SYSTEM_LINK;
       ia_state_ |= STATE_SYSTEM_LINKED;
       break;
-    case WebKit::WebAXRoleList:
+    case blink::WebAXRoleList:
       ia_role_ = ROLE_SYSTEM_LIST;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleListBox:
+    case blink::WebAXRoleListBox:
       ia_role_ = ROLE_SYSTEM_LIST;
       break;
-    case WebKit::WebAXRoleListBoxOption:
+    case blink::WebAXRoleListBoxOption:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
         ia_state_ |= STATE_SYSTEM_FOCUSABLE;
-        if (HasState(WebKit::WebAXStateFocused))
+        if (HasState(blink::WebAXStateFocused))
           ia_state_ |= STATE_SYSTEM_FOCUSED;
       }
       break;
-    case WebKit::WebAXRoleListItem:
+    case blink::WebAXRoleListItem:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleListMarker:
+    case blink::WebAXRoleListMarker:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleMath:
+    case blink::WebAXRoleMath:
       ia_role_ = ROLE_SYSTEM_EQUATION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleMenu:
-    case WebKit::WebAXRoleMenuButton:
+    case blink::WebAXRoleMenu:
+    case blink::WebAXRoleMenuButton:
       ia_role_ = ROLE_SYSTEM_MENUPOPUP;
       break;
-    case WebKit::WebAXRoleMenuBar:
+    case blink::WebAXRoleMenuBar:
       ia_role_ = ROLE_SYSTEM_MENUBAR;
       break;
-    case WebKit::WebAXRoleMenuItem:
+    case blink::WebAXRoleMenuItem:
       ia_role_ = ROLE_SYSTEM_MENUITEM;
       break;
-    case WebKit::WebAXRoleMenuListPopup:
+    case blink::WebAXRoleMenuListPopup:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       break;
-    case WebKit::WebAXRoleMenuListOption:
+    case blink::WebAXRoleMenuListOption:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
         ia_state_ |= STATE_SYSTEM_FOCUSABLE;
-        if (HasState(WebKit::WebAXStateFocused))
+        if (HasState(blink::WebAXStateFocused))
           ia_state_ |= STATE_SYSTEM_FOCUSED;
       }
       break;
-    case WebKit::WebAXRoleNote:
+    case blink::WebAXRoleNote:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_NOTE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleOutline:
+    case blink::WebAXRoleOutline:
       ia_role_ = ROLE_SYSTEM_OUTLINE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleParagraph:
+    case blink::WebAXRoleParagraph:
       role_name_ = L"P";
       ia2_role_ = IA2_ROLE_PARAGRAPH;
       break;
-    case WebKit::WebAXRolePopUpButton:
+    case blink::WebAXRolePopUpButton:
       if (html_tag == L"select") {
         ia_role_ = ROLE_SYSTEM_COMBOBOX;
       } else {
         ia_role_ = ROLE_SYSTEM_BUTTONMENU;
       }
       break;
-    case WebKit::WebAXRoleProgressIndicator:
+    case blink::WebAXRoleProgressIndicator:
       ia_role_ = ROLE_SYSTEM_PROGRESSBAR;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleRadioButton:
+    case blink::WebAXRoleRadioButton:
       ia_role_ = ROLE_SYSTEM_RADIOBUTTON;
       break;
-    case WebKit::WebAXRoleRadioGroup:
+    case blink::WebAXRoleRadioGroup:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       break;
-    case WebKit::WebAXRoleRegion:
+    case blink::WebAXRoleRegion:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleRow:
+    case blink::WebAXRoleRow:
       ia_role_ = ROLE_SYSTEM_ROW;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleRowHeader:
+    case blink::WebAXRoleRowHeader:
       ia_role_ = ROLE_SYSTEM_ROWHEADER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleRuler:
+    case blink::WebAXRoleRuler:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_RULER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleScrollArea:
+    case blink::WebAXRoleScrollArea:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_SCROLL_PANE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleScrollBar:
+    case blink::WebAXRoleScrollBar:
       ia_role_ = ROLE_SYSTEM_SCROLLBAR;
       break;
-    case WebKit::WebAXRoleSlider:
+    case blink::WebAXRoleSlider:
       ia_role_ = ROLE_SYSTEM_SLIDER;
       break;
-    case WebKit::WebAXRoleSpinButton:
+    case blink::WebAXRoleSpinButton:
       ia_role_ = ROLE_SYSTEM_SPINBUTTON;
       break;
-    case WebKit::WebAXRoleSpinButtonPart:
+    case blink::WebAXRoleSpinButtonPart:
       ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
       break;
-    case WebKit::WebAXRoleSplitGroup:
+    case blink::WebAXRoleSplitGroup:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_SPLIT_PANE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleAnnotation:
-    case WebKit::WebAXRoleStaticText:
+    case blink::WebAXRoleAnnotation:
+    case blink::WebAXRoleStaticText:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleStatus:
+    case blink::WebAXRoleStatus:
       ia_role_ = ROLE_SYSTEM_STATUSBAR;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleSplitter:
+    case blink::WebAXRoleSplitter:
       ia_role_ = ROLE_SYSTEM_SEPARATOR;
       break;
-    case WebKit::WebAXRoleSVGRoot:
+    case blink::WebAXRoleSVGRoot:
       ia_role_ = ROLE_SYSTEM_GRAPHIC;
       break;
-    case WebKit::WebAXRoleTab:
+    case blink::WebAXRoleTab:
       ia_role_ = ROLE_SYSTEM_PAGETAB;
       break;
-    case WebKit::WebAXRoleTable: {
+    case blink::WebAXRoleTable: {
       string16 aria_role = GetString16Attribute(
           AccessibilityNodeData::ATTR_ROLE);
       if (aria_role == L"treegrid") {
         ia_role_ = ROLE_SYSTEM_OUTLINE;
       } else {
         ia_role_ = ROLE_SYSTEM_TABLE;
         ia_state_ |= STATE_SYSTEM_READONLY;
       }
       break;
     }
-    case WebKit::WebAXRoleTableHeaderContainer:
+    case blink::WebAXRoleTableHeaderContainer:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleTabList:
+    case blink::WebAXRoleTabList:
       ia_role_ = ROLE_SYSTEM_PAGETABLIST;
       break;
-    case WebKit::WebAXRoleTabPanel:
+    case blink::WebAXRoleTabPanel:
       ia_role_ = ROLE_SYSTEM_PROPERTYPAGE;
       break;
-    case WebKit::WebAXRoleToggleButton:
+    case blink::WebAXRoleToggleButton:
       ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
       ia2_role_ = IA2_ROLE_TOGGLE_BUTTON;
       break;
-    case WebKit::WebAXRoleTextArea:
+    case blink::WebAXRoleTextArea:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_state_ |= IA2_STATE_MULTI_LINE;
       ia2_state_ |= IA2_STATE_EDITABLE;
       ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
       break;
-    case WebKit::WebAXRoleTextField:
+    case blink::WebAXRoleTextField:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_state_ |= IA2_STATE_SINGLE_LINE;
       ia2_state_ |= IA2_STATE_EDITABLE;
       ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
       break;
-    case WebKit::WebAXRoleTimer:
+    case blink::WebAXRoleTimer:
       ia_role_ = ROLE_SYSTEM_CLOCK;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleToolbar:
+    case blink::WebAXRoleToolbar:
       ia_role_ = ROLE_SYSTEM_TOOLBAR;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleUserInterfaceTooltip:
+    case blink::WebAXRoleUserInterfaceTooltip:
       ia_role_ = ROLE_SYSTEM_TOOLTIP;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleTree:
+    case blink::WebAXRoleTree:
       ia_role_ = ROLE_SYSTEM_OUTLINE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleTreeGrid:
+    case blink::WebAXRoleTreeGrid:
       ia_role_ = ROLE_SYSTEM_OUTLINE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleTreeItem:
+    case blink::WebAXRoleTreeItem:
       ia_role_ = ROLE_SYSTEM_OUTLINEITEM;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case WebKit::WebAXRoleWindow:
+    case blink::WebAXRoleWindow:
       ia_role_ = ROLE_SYSTEM_WINDOW;
       break;
 
     // TODO(dmazzoni): figure out the proper MSAA role for all of these.
-    case WebKit::WebAXRoleBrowser:
-    case WebKit::WebAXRoleDirectory:
-    case WebKit::WebAXRoleDrawer:
-    case WebKit::WebAXRoleHelpTag:
-    case WebKit::WebAXRoleIgnored:
-    case WebKit::WebAXRoleIncrementor:
-    case WebKit::WebAXRoleLog:
-    case WebKit::WebAXRoleMarquee:
-    case WebKit::WebAXRoleMatte:
-    case WebKit::WebAXRolePresentational:
-    case WebKit::WebAXRoleRulerMarker:
-    case WebKit::WebAXRoleSheet:
-    case WebKit::WebAXRoleSliderThumb:
-    case WebKit::WebAXRoleSystemWide:
-    case WebKit::WebAXRoleValueIndicator:
+    case blink::WebAXRoleBrowser:
+    case blink::WebAXRoleDirectory:
+    case blink::WebAXRoleDrawer:
+    case blink::WebAXRoleHelpTag:
+    case blink::WebAXRoleIgnored:
+    case blink::WebAXRoleIncrementor:
+    case blink::WebAXRoleLog:
+    case blink::WebAXRoleMarquee:
+    case blink::WebAXRoleMatte:
+    case blink::WebAXRolePresentational:
+    case blink::WebAXRoleRulerMarker:
+    case blink::WebAXRoleSheet:
+    case blink::WebAXRoleSliderThumb:
+    case blink::WebAXRoleSystemWide:
+    case blink::WebAXRoleValueIndicator:
     default:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       break;
   }
 
   // Compute the final value of READONLY for MSAA.
   //
   // We always set the READONLY state for elements that have the
   // aria-readonly attribute and for a few roles (in the switch above).
   // We clear the READONLY state on focusable controls and on a document.
   // Everything else, the majority of objects, do not have this state set.
-  if (HasState(WebKit::WebAXStateFocusable) &&
+  if (HasState(blink::WebAXStateFocusable) &&
       ia_role_ != ROLE_SYSTEM_DOCUMENT) {
     ia_state_ &= ~(STATE_SYSTEM_READONLY);
   }
-  if (!HasState(WebKit::WebAXStateReadonly))
+  if (!HasState(blink::WebAXStateReadonly))
     ia_state_ &= ~(STATE_SYSTEM_READONLY);
   if (GetBoolAttribute(AccessibilityNodeData::ATTR_ARIA_READONLY))
     ia_state_ |= STATE_SYSTEM_READONLY;
 
   // The role should always be set.
   DCHECK(!role_name_.empty() || ia_role_);
 
   // If we didn't explicitly set the IAccessible2 role, make it the same
   // as the MSAA role.
   if (!ia2_role_)
     ia2_role_ = ia_role_;
 }
 
 }  // namespace content