Enable toggling of new accessibility modes in chrome://accessibility

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 47 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->SetBoolean(
+      kAccessibilityModeField,
+      0 != (accessibility_mode & AccessibilityModeFlagWebContents));
   return target_data;
 }
 
 std::unique_ptr<base::DictionaryValue> BuildTargetDescriptor(
     RenderViewHost* rvh) {
   WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
       WebContents::FromRenderViewHost(rvh));
   AccessibilityMode accessibility_mode = AccessibilityModeOff;
 
   std::string title;
@@ skipping 38 matching lines @@
       continue;
     BrowserContext* context = rvh->GetProcess()->GetBrowserContext();
     if (context != current_context)
       continue;
 
     rvh_list->Append(BuildTargetDescriptor(rvh));
   }
 
   base::DictionaryValue data;
   data.Set("list", rvh_list.release());
-  data.SetInteger(
-      "global_a11y_mode",
-      BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode());
-  data.SetBoolean(
-      "global_internal_tree_mode",
-      g_show_internal_accessibility_tree);
+  AccessibilityMode mode =
+      BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode();
+  data.SetInteger("native",
+                  0 != (mode & AccessibilityModeFlagNativeAPIs));
+  data.SetInteger("web",
+                  0 != (mode & AccessibilityModeFlagWebContents));
+  data.SetInteger("text",
+                  0 != (mode & AccessibilityModeFlagInlineTextBoxes));
+  data.SetInteger("screenreader",
+                  0 != (mode & AccessibilityModeFlagScreenReader));
+  data.SetInteger("html",
+                  0 != (mode & AccessibilityModeFlagHTML));
+  data.SetBoolean("internal", g_show_internal_accessibility_tree);
 
   std::string json_string;
   base::JSONWriter::Write(data, &json_string);
 
   callback.Run(base::RefCountedString::TakeString(&json_string));
   return true;
 }
 
 }  // namespace
 
 AccessibilityUI::AccessibilityUI(WebUI* web_ui) : WebUIController(web_ui) {
   // Set up the chrome://accessibility source.
   WebUIDataSourceImpl* html_source = static_cast<WebUIDataSourceImpl*>(
       WebUIDataSource::Create(kChromeUIAccessibilityHost));
 
   web_ui->RegisterMessageCallback(
       "toggleAccessibility",
       base::Bind(&AccessibilityUI::ToggleAccessibility,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
-      "toggleGlobalAccessibility",
-      base::Bind(&AccessibilityUI::ToggleGlobalAccessibility,
-                 base::Unretained(this)));
-  web_ui->RegisterMessageCallback(
-      "toggleInternalTree",
-      base::Bind(&AccessibilityUI::ToggleInternalTree,
+      "setGlobalFlag",
+      base::Bind(&AccessibilityUI::SetGlobalFlag,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "requestAccessibilityTree",
       base::Bind(&AccessibilityUI::RequestAccessibilityTree,
                  base::Unretained(this)));
 
   // Add required resources.
   html_source->SetJsonPath("strings.js");
   html_source->AddResourcePath("accessibility.css", IDR_ACCESSIBILITY_CSS);
   html_source->AddResourcePath("accessibility.js", IDR_ACCESSIBILITY_JS);
@@ skipping 29 matching lines @@
       static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(rvh));
   AccessibilityMode mode = web_contents->GetAccessibilityMode();
   if ((mode & kAccessibilityModeComplete) != kAccessibilityModeComplete) {
     web_contents->AddAccessibilityMode(kAccessibilityModeComplete);
   } else {
     web_contents->SetAccessibilityMode(
         BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode());
   }
 }
 
-void AccessibilityUI::ToggleGlobalAccessibility(const base::ListValue* args) {
+void AccessibilityUI::SetGlobalFlag(const base::ListValue* args) {
+  std::string flag_name_str;
+  bool value;

[aboxhall, 2016/12/12 20:34:45]

how about s/value/enabled/ ?

[dmazzoni, 2016/12/13 00:30:49]

Done.

+  CHECK_EQ(2U, args->GetSize());
+  CHECK(args->GetString(0, &flag_name_str));
+  CHECK(args->GetBoolean(1, &value));
+
+  if (flag_name_str == "internal") {
+    g_show_internal_accessibility_tree = value;
+    return;
+  }
+
+  AccessibilityMode new_mode;
+  if (flag_name_str == "native") {
+    new_mode = AccessibilityModeFlagNativeAPIs;
+  } else if (flag_name_str == "web") {
+    new_mode = AccessibilityModeFlagWebContents;
+  } else if (flag_name_str == "text") {
+    new_mode = AccessibilityModeFlagInlineTextBoxes;
+  } else if (flag_name_str == "screenreader") {
+    new_mode = AccessibilityModeFlagScreenReader;
+  } else if (flag_name_str == "html") {
+    new_mode = AccessibilityModeFlagHTML;
+  } 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 (value == true &&

[aboxhall, 2016/12/12 20:34:45]

then you can s/== true// here and s/value == false/!enabled/ below

[dmazzoni, 2016/12/13 00:30:50]

Done.

+      (new_mode == AccessibilityModeFlagInlineTextBoxes ||
+       new_mode == AccessibilityModeFlagScreenReader ||
+       new_mode == AccessibilityModeFlagHTML)) {
+    new_mode |= AccessibilityModeFlagWebContents;
+  }
+
+  // Similarly if you disable web accessibility we should remove all

[aboxhall, 2016/12/12 20:34:45]

Is that true? Could they not stick around to be "remembered" for when you turn
WebContentsAccessibility back on?

[dmazzoni, 2016/12/13 00:30:50]

OK, how about this: I modified the code to show them as
disabled when they're not applicable. Is that better?

+  // flags that depend on it.
+  if (value == false && new_mode == AccessibilityModeFlagWebContents) {
+    new_mode |= AccessibilityModeFlagInlineTextBoxes;
+    new_mode |= AccessibilityModeFlagScreenReader;
+    new_mode |= AccessibilityModeFlagHTML;
+  }
+
   BrowserAccessibilityStateImpl* state =
       BrowserAccessibilityStateImpl::GetInstance();
-  AccessibilityMode mode = state->accessibility_mode();
-  if ((mode & kAccessibilityModeComplete) != kAccessibilityModeComplete)
-    state->EnableAccessibility();
+  if (value)
+    state->AddAccessibilityModeFlags(new_mode);
   else
-    state->DisableAccessibility();
-}
-
-void AccessibilityUI::ToggleInternalTree(const base::ListValue* args) {
-  g_show_internal_accessibility_tree = !g_show_internal_accessibility_tree;
+    state->RemoveAccessibilityModeFlags(new_mode);
 }
 
 void AccessibilityUI::RequestAccessibilityTree(const base::ListValue* args) {
   std::string process_id_str;
   std::string route_id_str;
   int process_id;
   int route_id;
   CHECK_EQ(2U, args->GetSize());
   CHECK(args->GetString(0, &process_id_str));
   CHECK(args->GetString(1, &route_id_str));
@@ skipping 29 matching lines @@
       web_contents->GetRootBrowserAccessibilityManager()->GetRoot(),
       &accessibility_contents_utf16);
   result->Set("tree",
               new base::StringValue(
                   base::UTF16ToUTF8(accessibility_contents_utf16)));
   web_ui()->CallJavascriptFunctionUnsafe("accessibility.showTree",
                                          *(result.get()));
 }
 
 }  // namespace content