Rename WebKit namespace to blink (part 3)

content/browser/accessibility/browser_accessibility_manager.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_manager.h"
 
 #include "base/logging.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/common/accessibility_messages.h"
 
@@ skipping 51 matching lines @@
   if (!UpdateNodes(nodes))
     return;
   if (!focus_)
     SetFocus(root_, false);
 }
 
 // static
 AccessibilityNodeData BrowserAccessibilityManager::GetEmptyDocument() {
   AccessibilityNodeData empty_document;
   empty_document.id = 0;
-  empty_document.role = WebKit::WebAXRoleRootWebArea;
+  empty_document.role = blink::WebAXRoleRootWebArea;
   return empty_document;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetRoot() {
   return root_;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetFromRendererID(
     int32 renderer_id) {
   base::hash_map<int32, BrowserAccessibility*>::iterator iter =
       renderer_id_map_.find(renderer_id);
   if (iter != renderer_id_map_.end())
     return iter->second;
   return NULL;
 }
 
 void BrowserAccessibilityManager::GotFocus(bool touch_event_context) {
   if (!touch_event_context)
     osk_state_ = OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED;
 
   if (!focus_)
     return;
 
-  NotifyAccessibilityEvent(WebKit::WebAXEventFocus, focus_);
+  NotifyAccessibilityEvent(blink::WebAXEventFocus, focus_);
 }
 
 void BrowserAccessibilityManager::WasHidden() {
   osk_state_ = OSK_DISALLOWED_BECAUSE_TAB_HIDDEN;
 }
 
 void BrowserAccessibilityManager::GotMouseDown() {
   osk_state_ = OSK_ALLOWED_WITHIN_FOCUSED_OBJECT;
-  NotifyAccessibilityEvent(WebKit::WebAXEventFocus, focus_);
+  NotifyAccessibilityEvent(blink::WebAXEventFocus, focus_);
 }
 
 bool BrowserAccessibilityManager::IsOSKAllowed(const gfx::Rect& bounds) {
   if (!delegate_ || !delegate_->HasFocus())
     return false;
 
   gfx::Point touch_point = delegate_->GetLastTouchEventLocation();
   return bounds.Contains(touch_point);
 }
 
@@ skipping 16 matching lines @@
     // Update nodes that changed.
     if (!UpdateNodes(param.nodes))
       return;
 
     // Find the node corresponding to the id that's the target of the
     // event (which may not be the root of the update tree).
     BrowserAccessibility* node = GetFromRendererID(param.id);
     if (!node)
       continue;
 
-    WebKit::WebAXEvent event_type = param.event_type;
-    if (event_type == WebKit::WebAXEventFocus ||
-        event_type == WebKit::WebAXEventBlur) {
+    blink::WebAXEvent event_type = param.event_type;
+    if (event_type == blink::WebAXEventFocus ||
+        event_type == blink::WebAXEventBlur) {
       SetFocus(node, false);
 
       if (osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_HIDDEN &&
           osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED)
         osk_state_ = OSK_ALLOWED;
 
       // Don't send a native focus event if the window itself doesn't
       // have focus.
       if (delegate_ && !delegate_->HasFocus())
         continue;
     }
 
     // Send the event event to the operating system.
     NotifyAccessibilityEvent(event_type, node);
 
     // Set initial focus when a page is loaded.
-    if (event_type == WebKit::WebAXEventLoadComplete) {
+    if (event_type == blink::WebAXEventLoadComplete) {
       if (!focus_)
         SetFocus(root_, false);
       if (!delegate_ || delegate_->HasFocus())
-        NotifyAccessibilityEvent(WebKit::WebAXEventFocus, focus_);
+        NotifyAccessibilityEvent(blink::WebAXEventFocus, focus_);
     }
   }
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetFocus(
     BrowserAccessibility* root) {
   if (focus_ && (!root || focus_->IsDescendantOf(root)))
     return focus_;
 
   return NULL;
@@ skipping 150 matching lines @@
     if (new_child_ids.find(src.child_ids[i]) != new_child_ids.end())
       return false;
     new_child_ids.insert(src.child_ids[i]);
   }
 
   // Look up the node by id. If it's not found, then either the root
   // of the tree is being swapped, or we're out of sync with the renderer
   // and this is a serious error.
   BrowserAccessibility* instance = GetFromRendererID(src.id);
   if (!instance) {
-    if (src.role != WebKit::WebAXRoleRootWebArea)
+    if (src.role != blink::WebAXRoleRootWebArea)
       return false;
     instance = CreateNode(NULL, src.id, 0);
   }
 
   // TODO(dmazzoni): avoid a linear scan here.
   for (size_t i = 0; i < src.bool_attributes.size(); i++) {
     if (src.bool_attributes[i].first ==
         AccessibilityNodeData::ATTR_UPDATE_LOCATION_ONLY) {
       instance->SetLocation(src.location);
       return true;
@@ skipping 46 matching lines @@
     } else {
       child = CreateNode(instance, child_renderer_id, index_in_parent);
     }
     new_children.push_back(child);
   }
 
   // Finally, swap in the new children vector for the old.
   instance->SwapChildren(new_children);
 
   // Handle the case where this node is the new root of the tree.
-  if (src.role == WebKit::WebAXRoleRootWebArea &&
+  if (src.role == blink::WebAXRoleRootWebArea &&
       (!root_ || root_->renderer_id() != src.id)) {
     if (root_)
       root_->Destroy();
     if (focus_ == root_)
       SetFocus(instance, false);
     SetRoot(instance);
   }
 
   // Keep track of what node is focused.
-  if (src.role != WebKit::WebAXRoleRootWebArea &&
-      src.role != WebKit::WebAXRoleWebArea &&
-      (src.state >> WebKit::WebAXStateFocused & 1)) {
+  if (src.role != blink::WebAXRoleRootWebArea &&
+      src.role != blink::WebAXRoleWebArea &&
+      (src.state >> blink::WebAXStateFocused & 1)) {
     SetFocus(instance, false);
   }
   return success;
 }
 
 }  // namespace content