Rename WebKit namespace to blink (part 3)

content/renderer/accessibility/renderer_accessibility_complete.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/renderer/accessibility/renderer_accessibility_complete.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/renderer/accessibility/accessibility_node_serializer.h"
 #include "content/renderer/render_view_impl.h"
 #include "third_party/WebKit/public/web/WebAXObject.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
-using WebKit::WebAXObject;
-using WebKit::WebDocument;
-using WebKit::WebFrame;
-using WebKit::WebNode;
-using WebKit::WebPoint;
-using WebKit::WebRect;
-using WebKit::WebSize;
-using WebKit::WebView;
+using blink::WebAXObject;
+using blink::WebDocument;
+using blink::WebFrame;
+using blink::WebNode;
+using blink::WebPoint;
+using blink::WebRect;
+using blink::WebSize;
+using blink::WebView;
 
 namespace content {
 
 RendererAccessibilityComplete::RendererAccessibilityComplete(
     RenderViewImpl* render_view)
     : RendererAccessibility(render_view),
       weak_factory_(this),
       browser_root_(NULL),
       last_scroll_offset_(gfx::Size()),
       ack_pending_(false) {
   WebAXObject::enableAccessibility();
   WebAXObject::enableInlineTextBoxAccessibility();
 
   const WebDocument& document = GetMainDocument();
   if (!document.isNull()) {
     // It's possible that the webview has already loaded a webpage without
     // accessibility being enabled. Initialize the browser's cached
     // accessibility tree by sending it a notification.
     HandleWebAccessibilityEvent(document.accessibilityObject(),
-                                WebKit::WebAXEventLayoutComplete);
+                                blink::WebAXEventLayoutComplete);
   }
 }
 
 RendererAccessibilityComplete::~RendererAccessibilityComplete() {
 }
 
 bool RendererAccessibilityComplete::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RendererAccessibilityComplete, message)
@@ skipping 16 matching lines @@
 
 void RendererAccessibilityComplete::FocusedNodeChanged(const WebNode& node) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   if (node.isNull()) {
     // When focus is cleared, implicitly focus the document.
     // TODO(dmazzoni): Make WebKit send this notification instead.
     HandleWebAccessibilityEvent(document.accessibilityObject(),
-                                WebKit::WebAXEventBlur);
+                                blink::WebAXEventBlur);
   }
 }
 
-void RendererAccessibilityComplete::DidFinishLoad(WebKit::WebFrame* frame) {
+void RendererAccessibilityComplete::DidFinishLoad(blink::WebFrame* frame) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   // Check to see if the root accessibility object has changed, to work
   // around WebKit bugs that cause AXObjectCache to be cleared
   // unnecessarily.
   // TODO(dmazzoni): remove this once rdar://5794454 is fixed.
   WebAXObject new_root = document.accessibilityObject();
   if (!browser_root_ || new_root.axID() != browser_root_->id)
-    HandleWebAccessibilityEvent(new_root, WebKit::WebAXEventLayoutComplete);
+    HandleWebAccessibilityEvent(new_root, blink::WebAXEventLayoutComplete);
 }
 
 void RendererAccessibilityComplete::HandleWebAccessibilityEvent(
-    const WebKit::WebAXObject& obj,
-    WebKit::WebAXEvent event) {
+    const blink::WebAXObject& obj,
+    blink::WebAXEvent event) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   gfx::Size scroll_offset = document.frame()->scrollOffset();
   if (scroll_offset != last_scroll_offset_) {
     // Make sure the browser is always aware of the scroll position of
     // the root document element by posting a generic notification that
     // will update it.
     // TODO(dmazzoni): remove this as soon as
     // https://bugs.webkit.org/show_bug.cgi?id=73460 is fixed.
     last_scroll_offset_ = scroll_offset;
     if (!obj.equals(document.accessibilityObject())) {
       HandleWebAccessibilityEvent(
           document.accessibilityObject(),
-          WebKit::WebAXEventLayoutComplete);
+          blink::WebAXEventLayoutComplete);
     }
   }
 
   // Add the accessibility object to our cache and ensure it's valid.
   AccessibilityHostMsg_EventParams acc_event;
   acc_event.id = obj.axID();
   acc_event.event_type = event;
 
   // Discard duplicate accessibility events.
   for (uint32 i = 0; i < pending_events_.size(); ++i) {
@@ skipping 51 matching lines @@
 
     WebAXObject obj = document.accessibilityObjectFromID(
         event.id);
     if (!obj.updateBackingStoreAndCheckValidity())
       continue;
 
     // When we get a "selected children changed" event, WebKit
     // doesn't also send us events for each child that changed
     // selection state, so make sure we re-send that whole subtree.
     if (event.event_type ==
-        WebKit::WebAXEventSelectedChildrenChanged) {
+        blink::WebAXEventSelectedChildrenChanged) {
       base::hash_map<int32, BrowserTreeNode*>::iterator iter =
           browser_id_map_.find(obj.axID());
       if (iter != browser_id_map_.end())
         ClearBrowserTreeNode(iter->second);
     }
 
     // The browser may not have this object yet, for example if we get a
     // event on an object that was recently added, or if we get a
     // event on a node before the page has loaded. Work our way
     // up the parent chain until we find a node the browser has, or until
     // we reach the root.
     WebAXObject root_object = document.accessibilityObject();
     int root_id = root_object.axID();
     while (browser_id_map_.find(obj.axID()) == browser_id_map_.end() &&
            !obj.isDetached() &&
            obj.axID() != root_id) {
       obj = obj.parentObject();
       if (event.event_type ==
-          WebKit::WebAXEventChildrenChanged) {
+          blink::WebAXEventChildrenChanged) {
         event.id = obj.axID();
       }
     }
 
     if (obj.isDetached()) {
 #ifndef NDEBUG
       if (logging_)
         LOG(WARNING) << "Got event on object that is invalid or has"
                      << " invalid ancestor. Id: " << obj.axID();
 #endif
@@ skipping 80 matching lines @@
     }
 
     for (unsigned i = 0; i < obj.childCount(); ++i)
       objs_to_explore.push(obj.childAt(i));
   }
 
   if (location_changes.size() == 0)
     return;
 
   AccessibilityHostMsg_EventParams event_msg;
-  event_msg.event_type = static_cast<WebKit::WebAXEvent>(-1);
+  event_msg.event_type = static_cast<blink::WebAXEvent>(-1);
   event_msg.id = root_object.axID();
   event_msg.nodes.resize(location_changes.size());
   for (size_t i = 0; i < location_changes.size(); i++) {
     AccessibilityNodeData& serialized_node = event_msg.nodes[i];
     serialized_node.id = location_changes[i]->id;
     serialized_node.location = location_changes[i]->location;
     serialized_node.AddBoolAttribute(
         AccessibilityNodeData::ATTR_UPDATE_LOCATION_ONLY, true);
   }
 
   event_msgs->push_back(event_msg);
 }
 
 RendererAccessibilityComplete::BrowserTreeNode*
 RendererAccessibilityComplete::CreateBrowserTreeNode() {
   return new RendererAccessibilityComplete::BrowserTreeNode();
 }
 
 void RendererAccessibilityComplete::SerializeChangedNodes(
-    const WebKit::WebAXObject& obj,
+    const blink::WebAXObject& obj,
     std::vector<AccessibilityNodeData>* dst,
     std::set<int>* ids_serialized) {
   if (ids_serialized->find(obj.axID()) != ids_serialized->end())
     return;
   ids_serialized->insert(obj.axID());
 
   // This method has three responsibilities:
   // 1. Serialize |obj| into an AccessibilityNodeData, and append it to
   //    the end of the |dst| vector to be send to the browser process.
   // 2. Determine if |obj| has any new children that the browser doesn't
@@ skipping 82 matching lines @@
       browser_child_id_map[old_child_id] = old_child;
     }
   }
 
   // Serialize this node. This fills in all of the fields in
   // AccessibilityNodeData except child_ids, which we handle below.
   dst->push_back(AccessibilityNodeData());
   AccessibilityNodeData* serialized_node = &dst->back();
   SerializeAccessibilityNode(obj, serialized_node);
   if (serialized_node->id == browser_root_->id)
-    serialized_node->role = WebKit::WebAXRoleRootWebArea;
+    serialized_node->role = blink::WebAXRoleRootWebArea;
 
   // Iterate over the children, make note of the ones that are new
   // and need to be serialized, and update the BrowserTreeNode
   // data structure to reflect the new tree.
   std::vector<WebAXObject> children_to_serialize;
   int child_count = obj.childCount();
   browser_node->children.reserve(child_count);
   for (int i = 0; i < child_count; i++) {
     WebAXObject child = obj.childAt(i);
     int child_id = child.axID();
@@ skipping 75 matching lines @@
   obj.scrollToMakeVisibleWithSubFocus(
       WebRect(subfocus.x(), subfocus.y(),
               subfocus.width(), subfocus.height()));
 
   // Make sure the browser gets an event when the scroll
   // position actually changes.
   // TODO(dmazzoni): remove this once this bug is fixed:
   // https://bugs.webkit.org/show_bug.cgi?id=73460
   HandleWebAccessibilityEvent(
       document.accessibilityObject(),
-      WebKit::WebAXEventLayoutComplete);
+      blink::WebAXEventLayoutComplete);
 }
 
 void RendererAccessibilityComplete::OnScrollToPoint(
     int acc_obj_id, gfx::Point point) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
   if (obj.isDetached()) {
 #ifndef NDEBUG
     if (logging_)
       LOG(WARNING) << "ScrollToPoint on invalid object id " << acc_obj_id;
 #endif
     return;
   }
 
   obj.scrollToGlobalPoint(WebPoint(point.x(), point.y()));
 
   // Make sure the browser gets an event when the scroll
   // position actually changes.
   // TODO(dmazzoni): remove this once this bug is fixed:
   // https://bugs.webkit.org/show_bug.cgi?id=73460
   HandleWebAccessibilityEvent(
       document.accessibilityObject(),
-      WebKit::WebAXEventLayoutComplete);
+      blink::WebAXEventLayoutComplete);
 }
 
 void RendererAccessibilityComplete::OnSetTextSelection(
     int acc_obj_id, int start_offset, int end_offset) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
   if (obj.isDetached()) {
 #ifndef NDEBUG
     if (logging_)
       LOG(WARNING) << "SetTextSelection on invalid object id " << acc_obj_id;
 #endif
     return;
   }
 
   // TODO(dmazzoni): support elements other than <input>.
-  WebKit::WebNode node = obj.node();
+  blink::WebNode node = obj.node();
   if (!node.isNull() && node.isElementNode()) {
-    WebKit::WebElement element = node.to<WebKit::WebElement>();
-    WebKit::WebInputElement* input_element =
-        WebKit::toWebInputElement(&element);
+    blink::WebElement element = node.to<blink::WebElement>();
+    blink::WebInputElement* input_element =
+        blink::toWebInputElement(&element);
     if (input_element && input_element->isTextField())
       input_element->setSelectionRange(start_offset, end_offset);
   }
 }
 
 void RendererAccessibilityComplete::OnEventsAck() {
   DCHECK(ack_pending_);
   ack_pending_ = false;
   SendPendingAccessibilityEvents();
 }
@@ skipping 30 matching lines @@
     render_view()->GetWebView()->clearFocusedNode();
   else
     obj.setFocused(true);
 }
 
 void RendererAccessibilityComplete::OnFatalError() {
   CHECK(false) << "Invalid accessibility tree.";
 }
 
 }  // namespace content