RWHI should implement BrowserAccessibilityDelegate

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 77 matching lines @@
 
 BrowserAccessibilityManager::~BrowserAccessibilityManager() {
   tree_.reset(NULL);
 }
 
 void BrowserAccessibilityManager::Initialize(
     const ui::AXTreeUpdate& initial_tree) {
   if (!tree_->Unserialize(initial_tree)) {
     if (delegate_) {
       LOG(ERROR) << tree_->error();
-      delegate_->FatalAccessibilityTreeError();
+      delegate_->AccessibilityFatalError();
     } else {
       LOG(FATAL) << tree_->error();
     }
   }
 
   if (!focus_)
     SetFocus(tree_->GetRoot(), false);
 }
 
 // static
@@ skipping 31 matching lines @@
 void BrowserAccessibilityManager::OnWindowBlurred() {
   if (focus_)
     NotifyAccessibilityEvent(ui::AX_EVENT_BLUR, GetFromAXNode(focus_));
 }
 
 void BrowserAccessibilityManager::GotMouseDown() {
   osk_state_ = OSK_ALLOWED_WITHIN_FOCUSED_OBJECT;
   NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(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);
-}
-
 bool BrowserAccessibilityManager::UseRootScrollOffsetsWhenComputingBounds() {
   return true;
 }
 
 void BrowserAccessibilityManager::OnAccessibilityEvents(
     const std::vector<AccessibilityHostMsg_EventParams>& params) {
   bool should_send_initial_focus = false;
 
   // Process all changes to the accessibility tree first.
   for (uint32 index = 0; index < params.size(); index++) {
     const AccessibilityHostMsg_EventParams& param = params[index];
     if (!tree_->Unserialize(param.update)) {
       if (delegate_) {
         LOG(ERROR) << tree_->error();
-        delegate_->FatalAccessibilityTreeError();
+        delegate_->AccessibilityFatalError();
       } else {
         CHECK(false) << tree_->error();
       }
       return;
     }
 
     // Set focus to the root if it's not anywhere else.
     if (!focus_) {
       SetFocus(tree_->GetRoot(), false);
       should_send_initial_focus = true;
     }
   }
 
   if (should_send_initial_focus &&
-      (!delegate_ || delegate_->HasFocus())) {
+      (!delegate_ || delegate_->AccessibilityViewHasFocus())) {
     NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
   }
 
   // Now iterate over the events again and fire the events.
   for (uint32 index = 0; index < params.size(); index++) {
     const AccessibilityHostMsg_EventParams& param = params[index];
 
     // Find the node corresponding to the id that's the target of the
     // event (which may not be the root of the update tree).
     ui::AXNode* node = tree_->GetFromId(param.id);
     if (!node)
       continue;
 
     ui::AXEvent event_type = param.event_type;
     if (event_type == ui::AX_EVENT_FOCUS ||
         event_type == ui::AX_EVENT_BLUR) {
       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())
+      if (delegate_ && !delegate_->AccessibilityViewHasFocus())
         continue;
     }
 
     // Send the event event to the operating system.
     NotifyAccessibilityEvent(event_type, GetFromAXNode(node));
   }
 }
 
 void BrowserAccessibilityManager::OnLocationChanges(
     const std::vector<AccessibilityHostMsg_LocationChangeParams>& params) {
@@ skipping 13 matching lines @@
     return GetFromAXNode(focus_);
 
   return NULL;
 }
 
 void BrowserAccessibilityManager::SetFocus(ui::AXNode* node, bool notify) {
   if (focus_ != node)
     focus_ = node;
 
   if (notify && node && delegate_)
-    delegate_->SetAccessibilityFocus(node->id());
+    delegate_->AccessibilitySetFocus(node->id());
 }
 
 void BrowserAccessibilityManager::SetFocus(
     BrowserAccessibility* obj, bool notify) {
   if (obj->node())
     SetFocus(obj->node(), notify);
 }
 
 void BrowserAccessibilityManager::DoDefaultAction(
     const BrowserAccessibility& node) {
@@ skipping 18 matching lines @@
 void BrowserAccessibilityManager::SetTextSelection(
     const BrowserAccessibility& node, int start_offset, int end_offset) {
   if (delegate_) {
     delegate_->AccessibilitySetTextSelection(
         node.GetId(), start_offset, end_offset);
   }
 }
 
 gfx::Rect BrowserAccessibilityManager::GetViewBounds() {
   if (delegate_)
-    return delegate_->GetViewBounds();
+    return delegate_->AccessibilityGetViewBounds();
   return gfx::Rect();
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::NextInTreeOrder(
     BrowserAccessibility* node) {
   if (!node)
     return NULL;
 
   if (node->PlatformChildCount() > 0)
     return node->PlatformGetChild(0);
@@ skipping 50 matching lines @@
 
 void BrowserAccessibilityManager::OnNodeCreationFinished(ui::AXNode* node) {
   GetFromAXNode(node)->OnUpdateFinished();
 }
 
 void BrowserAccessibilityManager::OnNodeChangeFinished(ui::AXNode* node) {
   GetFromAXNode(node)->OnUpdateFinished();
 }
 
 }  // namespace content