Scope and clean up uses of AccessibilityMode.

content/browser/accessibility/accessibility_ui.cc

 // Copyright (c) 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/accessibility/accessibility_ui.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 63 matching lines @@
     AccessibilityMode accessibility_mode,
     base::ProcessHandle handle = base::kNullProcessHandle) {
   std::unique_ptr<base::DictionaryValue> target_data(
       new base::DictionaryValue());
   target_data->SetInteger(kProcessIdField, process_id);
   target_data->SetInteger(kRouteIdField, route_id);
   target_data->SetString(kUrlField, url.spec());
   target_data->SetString(kNameField, net::EscapeForHTML(name));
   target_data->SetInteger(kPidField, base::GetProcId(handle));
   target_data->SetString(kFaviconUrlField, favicon_url.spec());
-  target_data->SetInteger(kAccessibilityModeField, accessibility_mode);
+  target_data->SetInteger(kAccessibilityModeField,
+                          accessibility_mode.get_mode());
   return target_data;
 }
 
 std::unique_ptr<base::DictionaryValue> BuildTargetDescriptor(
     RenderViewHost* rvh) {
   WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
       WebContents::FromRenderViewHost(rvh));
-  AccessibilityMode accessibility_mode = AccessibilityModeOff;
+  AccessibilityMode accessibility_mode;
 
   std::string title;
   GURL url;
   GURL favicon_url;
   if (web_contents) {
     // TODO(nasko): Fix the following code to use a consistent set of data
     // across the URL, title, and favicon.
     url = web_contents->GetURL();
     title = base::UTF16ToUTF8(web_contents->GetTitle());
     NavigationController& controller = web_contents->GetController();
@@ skipping 37 matching lines @@
 
     rvh_list->Append(BuildTargetDescriptor(rvh));
   }
 
   base::DictionaryValue data;
   data.Set("list", rvh_list.release());
   AccessibilityMode mode =
       BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode();
   bool disabled = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableRendererAccessibility);
-  bool native = 0 != (mode & ACCESSIBILITY_MODE_FLAG_NATIVE_APIS);
-  bool web = 0 != (mode & ACCESSIBILITY_MODE_FLAG_WEB_CONTENTS);
-  bool text = 0 != (mode & ACCESSIBILITY_MODE_FLAG_INLINE_TEXT_BOXES);
-  bool screenreader = 0 != (mode & ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
-  bool html = 0 != (mode & ACCESSIBILITY_MODE_FLAG_HTML);
+  bool native = mode.has_mode(AccessibilityMode::kNativeAPIs);
+  bool web = mode.has_mode(AccessibilityMode::kWebContents);
+  bool text = mode.has_mode(AccessibilityMode::kInlineTextBoxes);
+  bool screenreader = mode.has_mode(AccessibilityMode::kScreenReader);
+  bool html = mode.has_mode(AccessibilityMode::kHTML);
 
   // The "native" and "web" flags are disabled if
   // --disable-renderer-accessibility is set.
   data.SetString(kNative, disabled ? kDisabled : (native ? kOn : kOff));
   data.SetString(kWeb, disabled ? kDisabled : (web ? kOn : kOff));
 
   // The "text", "screenreader", and "html" flags are only meaningful if
   // "web" is enabled.
   data.SetString(kText, web ? (text ? kOn : kOff) : kDisabled);
   data.SetString(kScreenReader, web ? (screenreader ? kOn : kOff) : kDisabled);
@@ skipping 51 matching lines @@
 
 void AccessibilityUI::ToggleAccessibility(const base::ListValue* args) {
   std::string process_id_str;
   std::string route_id_str;
   int process_id;
   int route_id;
   int mode;
   CHECK_EQ(3U, args->GetSize());
   CHECK(args->GetString(0, &process_id_str));
   CHECK(args->GetString(1, &route_id_str));
+  // TODO(695247): We should pass each ax flag seperately
   CHECK(args->GetInteger(2, &mode));
   CHECK(base::StringToInt(process_id_str, &process_id));
   CHECK(base::StringToInt(route_id_str, &route_id));
 
   RenderViewHost* rvh = RenderViewHost::FromID(process_id, route_id);
   if (!rvh)
     return;
   auto* web_contents =
       static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(rvh));
   AccessibilityMode current_mode = web_contents->GetAccessibilityMode();
-  // Flip the bits represented by |mode|. See accessibility_mode_enums.h for
-  // values.
-  current_mode ^= mode;
+
+  if (mode & AccessibilityMode::kNativeAPIs)
+    current_mode.set_mode(AccessibilityMode::kNativeAPIs, true);
+
+  if (mode & AccessibilityMode::kWebContents)
+    current_mode.set_mode(AccessibilityMode::kWebContents, true);
+
+  if (mode & AccessibilityMode::kInlineTextBoxes)
+    current_mode.set_mode(AccessibilityMode::kInlineTextBoxes, true);
+
+  if (mode & AccessibilityMode::kScreenReader)
+    current_mode.set_mode(AccessibilityMode::kScreenReader, true);
+
+  if (mode & AccessibilityMode::kHTML)
+    current_mode.set_mode(AccessibilityMode::kHTML, true);
+
   web_contents->SetAccessibilityMode(current_mode);
 }
 
 void AccessibilityUI::SetGlobalFlag(const base::ListValue* args) {
   std::string flag_name_str;
   bool enabled;
   CHECK_EQ(2U, args->GetSize());
   CHECK(args->GetString(0, &flag_name_str));
   CHECK(args->GetBoolean(1, &enabled));
 
   if (flag_name_str == kInternal) {
     g_show_internal_accessibility_tree = enabled;
     LOG(ERROR) << "INTERNAL: " << g_show_internal_accessibility_tree;
     return;
   }
 
   AccessibilityMode new_mode;
   if (flag_name_str == kNative) {
-    new_mode = ACCESSIBILITY_MODE_FLAG_NATIVE_APIS;
+    new_mode = AccessibilityMode::kNativeAPIs;
   } else if (flag_name_str == kWeb) {
-    new_mode = ACCESSIBILITY_MODE_FLAG_WEB_CONTENTS;
+    new_mode = AccessibilityMode::kWebContents;
   } else if (flag_name_str == kText) {
-    new_mode = ACCESSIBILITY_MODE_FLAG_INLINE_TEXT_BOXES;
+    new_mode = AccessibilityMode::kInlineTextBoxes;
   } else if (flag_name_str == kScreenReader) {
-    new_mode = ACCESSIBILITY_MODE_FLAG_SCREEN_READER;
+    new_mode = AccessibilityMode::kScreenReader;
   } else if (flag_name_str == kHTML) {
-    new_mode = ACCESSIBILITY_MODE_FLAG_HTML;
+    new_mode = AccessibilityMode::kHTML;
   } else {
     NOTREACHED();
     return;
   }
 
   // It doesn't make sense to enable one of the flags that depends on
   // web contents without enabling web contents accessibility too.
-  if (enabled &&
-      (new_mode == ACCESSIBILITY_MODE_FLAG_INLINE_TEXT_BOXES ||
-       new_mode == ACCESSIBILITY_MODE_FLAG_SCREEN_READER ||
-       new_mode == ACCESSIBILITY_MODE_FLAG_HTML)) {
-    new_mode |= ACCESSIBILITY_MODE_FLAG_WEB_CONTENTS;
+  if (enabled && (new_mode.has_mode(AccessibilityMode::kInlineTextBoxes) ||
+                  new_mode.has_mode(AccessibilityMode::kScreenReader) ||
+                  new_mode.has_mode(AccessibilityMode::kHTML))) {
+    new_mode.set_mode(AccessibilityMode::kWebContents, true);
   }
 
   // Similarly if you disable web accessibility we should remove all
   // flags that depend on it.
-  if (!enabled && new_mode == ACCESSIBILITY_MODE_FLAG_WEB_CONTENTS) {
-    new_mode |= ACCESSIBILITY_MODE_FLAG_INLINE_TEXT_BOXES;
-    new_mode |= ACCESSIBILITY_MODE_FLAG_SCREEN_READER;
-    new_mode |= ACCESSIBILITY_MODE_FLAG_HTML;
+  if (!enabled && new_mode.has_mode(AccessibilityMode::kWebContents)) {
+    new_mode.set_mode(AccessibilityMode::kInlineTextBoxes, true);
+    new_mode.set_mode(AccessibilityMode::kScreenReader, true);
+    new_mode.set_mode(AccessibilityMode::kHTML, true);
   }
 
   BrowserAccessibilityStateImpl* state =
       BrowserAccessibilityStateImpl::GetInstance();
   if (enabled)
     state->AddAccessibilityModeFlags(new_mode);
   else
     state->RemoveAccessibilityModeFlags(new_mode);
 }
 
@@ skipping 17 matching lines @@
     web_ui()->CallJavascriptFunctionUnsafe("accessibility.showTree",
                                            *(result.get()));
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> result(BuildTargetDescriptor(rvh));
   auto* web_contents =
       static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(rvh));
   // No matter the state of the current web_contents, we want to force the mode
   // because we are about to show the accessibility tree
-  web_contents->SetAccessibilityMode(ACCESSIBILITY_MODE_FLAG_NATIVE_APIS |
-                                     ACCESSIBILITY_MODE_FLAG_WEB_CONTENTS);
+  web_contents->SetAccessibilityMode(AccessibilityMode(
+      AccessibilityMode::kNativeAPIs | AccessibilityMode::kWebContents));
+
   std::unique_ptr<AccessibilityTreeFormatter> formatter;
   if (g_show_internal_accessibility_tree)
     formatter.reset(new AccessibilityTreeFormatterBlink());
   else
     formatter.reset(AccessibilityTreeFormatter::Create());
   base::string16 accessibility_contents_utf16;
   std::vector<AccessibilityTreeFormatter::Filter> filters;
   filters.push_back(AccessibilityTreeFormatter::Filter(
       base::ASCIIToUTF16("*"),
       AccessibilityTreeFormatter::Filter::ALLOW));
   formatter->SetFilters(filters);
   auto* ax_mgr = web_contents->GetOrCreateRootBrowserAccessibilityManager();
   DCHECK(ax_mgr);
   formatter->FormatAccessibilityTree(ax_mgr->GetRoot(),
                                      &accessibility_contents_utf16);
   result->Set("tree",
               new base::StringValue(
                   base::UTF16ToUTF8(accessibility_contents_utf16)));
   web_ui()->CallJavascriptFunctionUnsafe("accessibility.showTree",
                                          *(result.get()));
 }
 
 }  // namespace content