Scope and clean up uses of AccessibilityMode.

content/browser/frame_host/render_frame_host_impl.cc

 // Copyright 2013 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/frame_host/render_frame_host_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 1960 matching lines @@
   // reset but this message includes a reset token.
   if (accessibility_reset_token_ != reset_token) {
     Send(new AccessibilityMsg_Events_ACK(routing_id_, ack_token));
     return;
   }
   accessibility_reset_token_ = 0;
 
   RenderWidgetHostViewBase* view = GetViewForAccessibility();
 
   AccessibilityMode accessibility_mode = delegate_->GetAccessibilityMode();
-  if ((accessibility_mode != AccessibilityModeOff) && view && is_active()) {
-    if (accessibility_mode & ACCESSIBILITY_MODE_FLAG_NATIVE_APIS)
+  if (!accessibility_mode.is_mode_off() && view && is_active()) {
+    if (accessibility_mode.has_mode(AccessibilityMode::kNativeAPIs))
       GetOrCreateBrowserAccessibilityManager();
 
     std::vector<AXEventNotificationDetails> details;
     details.reserve(params.size());
     for (size_t i = 0; i < params.size(); ++i) {
       const AccessibilityHostMsg_EventParams& param = params[i];
       AXEventNotificationDetails detail;
       detail.event_type = param.event_type;
       detail.id = param.id;
       detail.ax_tree_id = GetAXTreeID();
       detail.event_from = param.event_from;
       if (param.update.has_tree_data) {
         detail.update.has_tree_data = true;
         ax_content_tree_data_ = param.update.tree_data;
         AXContentTreeDataToAXTreeData(&detail.update.tree_data);
       }
       detail.update.root_id = param.update.root_id;
       detail.update.node_id_to_clear = param.update.node_id_to_clear;
       detail.update.nodes.resize(param.update.nodes.size());
       for (size_t i = 0; i < param.update.nodes.size(); ++i) {
         AXContentNodeDataToAXNodeData(param.update.nodes[i],
                                       &detail.update.nodes[i]);
       }
       details.push_back(detail);
     }
 
-    if (accessibility_mode & ACCESSIBILITY_MODE_FLAG_NATIVE_APIS) {
+    if (accessibility_mode.has_mode(AccessibilityMode::kNativeAPIs)) {
       if (browser_accessibility_manager_)
         browser_accessibility_manager_->OnAccessibilityEvents(details);
     }
 
     delegate_->AccessibilityEventReceived(details);
 
     // For testing only.
     if (!accessibility_testing_callback_.is_null()) {
       for (size_t i = 0; i < details.size(); i++) {
         const AXEventNotificationDetails& detail = details[i];
@@ skipping 24 matching lines @@
 
 void RenderFrameHostImpl::OnAccessibilityLocationChanges(
     const std::vector<AccessibilityHostMsg_LocationChangeParams>& params) {
   if (accessibility_reset_token_)
     return;
 
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
       render_view_host_->GetWidget()->GetView());
   if (view && is_active()) {
     AccessibilityMode accessibility_mode = delegate_->GetAccessibilityMode();
-    if (accessibility_mode & ACCESSIBILITY_MODE_FLAG_NATIVE_APIS) {
+    if (accessibility_mode.has_mode(AccessibilityMode::kNativeAPIs)) {
       BrowserAccessibilityManager* manager =
           GetOrCreateBrowserAccessibilityManager();
       if (manager)
         manager->OnLocationChanges(params);
     }
 
     // Send the updates to the automation extension API.
     std::vector<AXLocationChangeNotificationDetails> details;
     details.reserve(params.size());
     for (size_t i = 0; i < params.size(); ++i) {
       const AccessibilityHostMsg_LocationChangeParams& param = params[i];
       AXLocationChangeNotificationDetails detail;
       detail.id = param.id;
       detail.ax_tree_id = GetAXTreeID();
       detail.new_location = param.new_location;
       details.push_back(detail);
     }
     delegate_->AccessibilityLocationChangesReceived(details);
   }
 }
 
 void RenderFrameHostImpl::OnAccessibilityFindInPageResult(
     const AccessibilityHostMsg_FindInPageResultParams& params) {
   AccessibilityMode accessibility_mode = delegate_->GetAccessibilityMode();
-  if (accessibility_mode & ACCESSIBILITY_MODE_FLAG_NATIVE_APIS) {
+  if (accessibility_mode.has_mode(AccessibilityMode::kNativeAPIs)) {
     BrowserAccessibilityManager* manager =
         GetOrCreateBrowserAccessibilityManager();
     if (manager) {
       manager->OnFindInPageResult(
           params.request_id, params.match_index, params.start_id,
           params.start_offset, params.end_id, params.end_offset);
     }
   }
 }
 
@@ skipping 849 matching lines @@
 
 bool RenderFrameHostImpl::IsSameSiteInstance(
     RenderFrameHostImpl* other_render_frame_host) {
   // As a sanity check, make sure the frame belongs to the same BrowserContext.
   CHECK_EQ(GetSiteInstance()->GetBrowserContext(),
            other_render_frame_host->GetSiteInstance()->GetBrowserContext());
   return GetSiteInstance() == other_render_frame_host->GetSiteInstance();
 }
 
 void RenderFrameHostImpl::UpdateAccessibilityMode() {
-  AccessibilityMode accessibility_mode = delegate_->GetAccessibilityMode();
-  Send(new FrameMsg_SetAccessibilityMode(routing_id_, accessibility_mode));
+  int accessibility_mode_raw = delegate_->GetAccessibilityMode().mode();
+  Send(new FrameMsg_SetAccessibilityMode(routing_id_, accessibility_mode_raw));
 }
 
 void RenderFrameHostImpl::RequestAXTreeSnapshot(
     AXTreeSnapshotCallback callback) {
   static int next_id = 1;
   int callback_id = next_id++;
   Send(new AccessibilityMsg_SnapshotTree(routing_id_, callback_id));
   ax_tree_snapshot_callbacks_.insert(std::make_pair(callback_id, callback));
 }
 
 void RenderFrameHostImpl::SetAccessibilityCallbackForTesting(
     const base::Callback<void(RenderFrameHostImpl*, ui::AXEvent, int)>&
         callback) {
   accessibility_testing_callback_ = callback;
 }
 
 void RenderFrameHostImpl::UpdateAXTreeData() {
   AccessibilityMode accessibility_mode = delegate_->GetAccessibilityMode();
-  if (accessibility_mode == AccessibilityModeOff || !is_active()) {
+  if (accessibility_mode.is_mode_off() || !is_active()) {
     return;
   }
 
   std::vector<AXEventNotificationDetails> details;
   details.reserve(1U);
   AXEventNotificationDetails detail;
   detail.ax_tree_id = GetAXTreeID();
   detail.update.has_tree_data = true;
   AXContentTreeDataToAXTreeData(&detail.update.tree_data);
   details.push_back(detail);
@@ skipping 23 matching lines @@
     bool is_root_frame = !frame_tree_node()->parent();
     browser_accessibility_manager_.reset(
         view->CreateBrowserAccessibilityManager(this, is_root_frame));
   }
   return browser_accessibility_manager_.get();
 }
 
 void RenderFrameHostImpl::ActivateFindInPageResultForAccessibility(
     int request_id) {
   AccessibilityMode accessibility_mode = delegate_->GetAccessibilityMode();
-  if (accessibility_mode & ACCESSIBILITY_MODE_FLAG_NATIVE_APIS) {
+  if (accessibility_mode.has_mode(AccessibilityMode::kNativeAPIs)) {
     BrowserAccessibilityManager* manager =
         GetOrCreateBrowserAccessibilityManager();
     if (manager)
       manager->ActivateFindInPageResult(request_id);
   }
 }
 
 void RenderFrameHostImpl::InsertVisualStateCallback(
     const VisualStateCallback& callback) {
   static uint64_t next_id = 1;
@@ skipping 464 matching lines @@
           GetUserData(kRenderFrameHostAndroidKey));
   if (!render_frame_host_android) {
     render_frame_host_android = new RenderFrameHostAndroid(this);
     SetUserData(kRenderFrameHostAndroidKey, render_frame_host_android);
   }
   return render_frame_host_android->GetJavaObject();
 }
 #endif
 
 }  // namespace content