chrome/browser/accessibility/accessibility_extension_api.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/accessibility/accessibility_extension_api.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/values.h"
  10 #include "chrome/browser/accessibility/accessibility_extension_api_constants.h"
  11 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
  12 #include "chrome/browser/extensions/extension_service.h"
  13 #include "chrome/browser/extensions/extension_tab_util.h"
  14 #include "chrome/browser/infobars/infobar_service.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/common/extensions/api/accessibility_private.h"
  17 #include "chrome/common/extensions/extension_constants.h"
  18 #include "components/infobars/core/confirm_infobar_delegate.h"
  19 #include "components/infobars/core/infobar.h"
  20 #include "content/public/browser/browser_accessibility_state.h"
  21 #include "extensions/browser/event_router.h"
  22 #include "extensions/browser/extension_host.h"
  23 #include "extensions/browser/extension_system.h"
  24 #include "extensions/browser/lazy_background_task_queue.h"
  25 #include "extensions/common/error_utils.h"
  26 #include "extensions/common/manifest_handlers/background_info.h"
  27
  28 #if defined(OS_CHROMEOS)
  29 #include "chrome/browser/chromeos/ui/accessibility_focus_ring_controller.h"
  30 #endif
  31
  32 namespace keys = extension_accessibility_api_constants;
  33 namespace accessibility_private = extensions::api::accessibility_private;
  34
  35 // Returns the AccessibilityControlInfo serialized into a JSON string,
  36 // consisting of an array of a single object of type AccessibilityObject,
  37 // as defined in the accessibility extension api's json schema.
  38 scoped_ptr<base::ListValue> ControlInfoToEventArguments(
  39     const AccessibilityEventInfo* info) {
  40   base::DictionaryValue* dict = new base::DictionaryValue();
  41   info->SerializeToDict(dict);
  42
  43   scoped_ptr<base::ListValue> args(new base::ListValue());
  44   args->Append(dict);
  45   return args.Pass();
  46 }
  47
  48 ExtensionAccessibilityEventRouter*
  49     ExtensionAccessibilityEventRouter::GetInstance() {
  50   return Singleton<ExtensionAccessibilityEventRouter>::get();
  51 }
  52
  53 ExtensionAccessibilityEventRouter::ExtensionAccessibilityEventRouter()
  54     : enabled_(false) {
  55 }
  56
  57 ExtensionAccessibilityEventRouter::~ExtensionAccessibilityEventRouter() {
  58   control_event_callback_.Reset();
  59 }
  60
  61 void ExtensionAccessibilityEventRouter::SetAccessibilityEnabled(bool enabled) {
  62   enabled_ = enabled;
  63 }
  64
  65 bool ExtensionAccessibilityEventRouter::IsAccessibilityEnabled() const {
  66   return enabled_;
  67 }
  68
  69 void ExtensionAccessibilityEventRouter::SetControlEventCallbackForTesting(
  70     ControlEventCallback control_event_callback) {
  71   DCHECK(control_event_callback_.is_null());
  72   control_event_callback_ = control_event_callback;
  73 }
  74
  75 void ExtensionAccessibilityEventRouter::ClearControlEventCallback() {
  76   control_event_callback_.Reset();
  77 }
  78
  79 void ExtensionAccessibilityEventRouter::HandleWindowEvent(
  80     ui::AXEvent event,
  81     const AccessibilityWindowInfo* info) {
  82   if (!control_event_callback_.is_null())
  83     control_event_callback_.Run(event, info);
  84
  85   if (event == ui::AX_EVENT_ALERT)
  86     OnWindowOpened(info);
  87 }
  88
  89 void ExtensionAccessibilityEventRouter::HandleMenuEvent(
  90     ui::AXEvent event,
  91     const AccessibilityMenuInfo* info) {
  92   switch (event) {
  93     case ui::AX_EVENT_MENU_START:
  94     case ui::AX_EVENT_MENU_POPUP_START:
  95       OnMenuOpened(info);
  96       break;
  97     case ui::AX_EVENT_MENU_END:
  98     case ui::AX_EVENT_MENU_POPUP_END:
  99       OnMenuClosed(info);
 100       break;
 101     case ui::AX_EVENT_FOCUS:
 102       OnControlFocused(info);
 103       break;
 104     case ui::AX_EVENT_HOVER:
 105       OnControlHover(info);
 106       break;
 107     default:
 108       NOTREACHED();
 109   }
 110 }
 111
 112 void ExtensionAccessibilityEventRouter::HandleControlEvent(
 113     ui::AXEvent event,
 114     const AccessibilityControlInfo* info) {
 115   if (!control_event_callback_.is_null())
 116     control_event_callback_.Run(event, info);
 117
 118   switch (event) {
 119     case ui::AX_EVENT_TEXT_CHANGED:
 120     case ui::AX_EVENT_TEXT_SELECTION_CHANGED:
 121       OnTextChanged(info);
 122       break;
 123     case ui::AX_EVENT_VALUE_CHANGED:
 124     case ui::AX_EVENT_ALERT:
 125       OnControlAction(info);
 126       break;
 127     case ui::AX_EVENT_FOCUS:
 128       OnControlFocused(info);
 129       break;
 130     case ui::AX_EVENT_HOVER:
 131       OnControlHover(info);
 132       break;
 133     default:
 134       NOTREACHED();
 135   }
 136 }
 137
 138 void ExtensionAccessibilityEventRouter::OnWindowOpened(
 139     const AccessibilityWindowInfo* info) {
 140   scoped_ptr<base::ListValue> args(ControlInfoToEventArguments(info));
 141   DispatchEvent(info->profile(),
 142                 accessibility_private::OnWindowOpened::kEventName,
 143                 args.Pass());
 144 }
 145
 146 void ExtensionAccessibilityEventRouter::OnControlFocused(
 147     const AccessibilityControlInfo* info) {
 148   last_focused_control_dict_.Clear();
 149   info->SerializeToDict(&last_focused_control_dict_);
 150   scoped_ptr<base::ListValue> args(ControlInfoToEventArguments(info));
 151   DispatchEvent(info->profile(),
 152                 accessibility_private::OnControlFocused::kEventName,
 153                 args.Pass());
 154 }
 155
 156 void ExtensionAccessibilityEventRouter::OnControlAction(
 157     const AccessibilityControlInfo* info) {
 158   scoped_ptr<base::ListValue> args(ControlInfoToEventArguments(info));
 159   DispatchEvent(info->profile(),
 160                 accessibility_private::OnControlAction::kEventName,
 161                 args.Pass());
 162 }
 163
 164 void ExtensionAccessibilityEventRouter::OnControlHover(
 165     const AccessibilityControlInfo* info) {
 166   scoped_ptr<base::ListValue> args(ControlInfoToEventArguments(info));
 167   DispatchEvent(info->profile(),
 168                 accessibility_private::OnControlHover::kEventName,
 169                 args.Pass());
 170 }
 171
 172 void ExtensionAccessibilityEventRouter::OnTextChanged(
 173     const AccessibilityControlInfo* info) {
 174   scoped_ptr<base::ListValue> args(ControlInfoToEventArguments(info));
 175   DispatchEvent(info->profile(),
 176                 accessibility_private::OnTextChanged::kEventName,
 177                 args.Pass());
 178 }
 179
 180 void ExtensionAccessibilityEventRouter::OnMenuOpened(
 181     const AccessibilityMenuInfo* info) {
 182   scoped_ptr<base::ListValue> args(ControlInfoToEventArguments(info));
 183   DispatchEvent(info->profile(),
 184                 accessibility_private::OnMenuOpened::kEventName,
 185                 args.Pass());
 186 }
 187
 188 void ExtensionAccessibilityEventRouter::OnMenuClosed(
 189     const AccessibilityMenuInfo* info) {
 190   scoped_ptr<base::ListValue> args(ControlInfoToEventArguments(info));
 191   DispatchEvent(info->profile(),
 192                 accessibility_private::OnMenuClosed::kEventName,
 193                 args.Pass());
 194 }
 195
 196 void ExtensionAccessibilityEventRouter::OnChromeVoxLoadStateChanged(
 197     Profile* profile,
 198     bool loading,
 199     bool make_announcements) {
 200   scoped_ptr<base::ListValue> event_args(new base::ListValue());
 201   event_args->AppendBoolean(loading);
 202   event_args->AppendBoolean(make_announcements);
 203   ExtensionAccessibilityEventRouter::DispatchEventToChromeVox(
 204       profile,
 205       accessibility_private::OnChromeVoxLoadStateChanged::kEventName,
 206       event_args.Pass());
 207 }
 208
 209 // Static.
 210 void ExtensionAccessibilityEventRouter::DispatchEventToChromeVox(
 211     Profile* profile,
 212     const char* event_name,
 213     scoped_ptr<base::ListValue> event_args) {
 214   extensions::ExtensionSystem* system =
 215       extensions::ExtensionSystem::Get(profile);
 216   if (!system)
 217     return;
 218   scoped_ptr<extensions::Event> event(new extensions::Event(event_name,
 219                                                             event_args.Pass()));
 220   system->event_router()->DispatchEventWithLazyListener(
 221       extension_misc::kChromeVoxExtensionId, event.Pass());
 222 }
 223
 224 void ExtensionAccessibilityEventRouter::DispatchEvent(
 225     Profile* profile,
 226     const char* event_name,
 227     scoped_ptr<base::ListValue> event_args) {
 228   if (!enabled_ || !profile)
 229     return;
 230   extensions::EventRouter* event_router = extensions::EventRouter::Get(profile);
 231   if (!event_router)
 232     return;
 233
 234   scoped_ptr<extensions::Event> event(new extensions::Event(
 235       event_name, event_args.Pass()));
 236   event_router->BroadcastEvent(event.Pass());
 237 }
 238
 239 bool AccessibilityPrivateSetAccessibilityEnabledFunction::RunSync() {
 240   bool enabled;
 241   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(0, &enabled));
 242   ExtensionAccessibilityEventRouter::GetInstance()
 243       ->SetAccessibilityEnabled(enabled);
 244   return true;
 245 }
 246
 247 bool AccessibilityPrivateSetNativeAccessibilityEnabledFunction::RunSync() {
 248   bool enabled;
 249   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(0, &enabled));
 250   if (enabled) {
 251     content::BrowserAccessibilityState::GetInstance()->
 252         EnableAccessibility();
 253   } else {
 254     content::BrowserAccessibilityState::GetInstance()->
 255         DisableAccessibility();
 256   }
 257   return true;
 258 }
 259
 260 bool AccessibilityPrivateGetFocusedControlFunction::RunSync() {
 261   // Get the serialized dict from the last focused control and return it.
 262   // However, if the dict is empty, that means we haven't seen any focus
 263   // events yet, so return null instead.
 264   ExtensionAccessibilityEventRouter *accessibility_event_router =
 265       ExtensionAccessibilityEventRouter::GetInstance();
 266   base::DictionaryValue *last_focused_control_dict =
 267       accessibility_event_router->last_focused_control_dict();
 268   if (last_focused_control_dict->size()) {
 269     SetResult(last_focused_control_dict->DeepCopyWithoutEmptyChildren());
 270   } else {
 271     SetResult(base::Value::CreateNullValue());
 272   }
 273   return true;
 274 }
 275
 276 bool AccessibilityPrivateGetAlertsForTabFunction::RunSync() {
 277   int tab_id;
 278   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 279
 280   TabStripModel* tab_strip = NULL;
 281   content::WebContents* contents = NULL;
 282   int tab_index = -1;
 283   if (!extensions::ExtensionTabUtil::GetTabById(tab_id,
 284                                                 GetProfile(),
 285                                                 include_incognito(),
 286                                                 NULL,
 287                                                 &tab_strip,
 288                                                 &contents,
 289                                                 &tab_index)) {
 290     error_ = extensions::ErrorUtils::FormatErrorMessage(
 291         extensions::tabs_constants::kTabNotFoundError,
 292         base::IntToString(tab_id));
 293     return false;
 294   }
 295
 296   base::ListValue* alerts_value = new base::ListValue;
 297
 298   InfoBarService* infobar_service = InfoBarService::FromWebContents(contents);
 299   for (size_t i = 0; i < infobar_service->infobar_count(); ++i) {
 300     // TODO(hashimoto): Make other kind of alerts available.  crosbug.com/24281
 301     ConfirmInfoBarDelegate* confirm_infobar_delegate =
 302         infobar_service->infobar_at(i)->delegate()->AsConfirmInfoBarDelegate();
 303     if (confirm_infobar_delegate) {
 304       base::DictionaryValue* alert_value = new base::DictionaryValue;
 305       const base::string16 message_text =
 306           confirm_infobar_delegate->GetMessageText();
 307       alert_value->SetString(keys::kMessageKey, message_text);
 308       alerts_value->Append(alert_value);
 309     }
 310   }
 311
 312   SetResult(alerts_value);
 313   return true;
 314 }
 315
 316 bool AccessibilityPrivateSetFocusRingFunction::RunSync() {
 317 #if defined(OS_CHROMEOS)
 318   base::ListValue* rect_values = NULL;
 319   EXTENSION_FUNCTION_VALIDATE(args_->GetList(0, &rect_values));
 320
 321   std::vector<gfx::Rect> rects;
 322   for (size_t i = 0; i < rect_values->GetSize(); ++i) {
 323     base::DictionaryValue* rect_value = NULL;
 324     EXTENSION_FUNCTION_VALIDATE(rect_values->GetDictionary(i, &rect_value));
 325     int left, top, width, height;
 326     EXTENSION_FUNCTION_VALIDATE(rect_value->GetInteger(keys::kLeft, &left));
 327     EXTENSION_FUNCTION_VALIDATE(rect_value->GetInteger(keys::kTop, &top));
 328     EXTENSION_FUNCTION_VALIDATE(rect_value->GetInteger(keys::kWidth, &width));
 329     EXTENSION_FUNCTION_VALIDATE(rect_value->GetInteger(keys::kHeight, &height));
 330     rects.push_back(gfx::Rect(left, top, width, height));
 331   }
 332
 333   chromeos::AccessibilityFocusRingController::GetInstance()->SetFocusRing(
 334       rects);
 335   return true;
 336 #endif  // defined(OS_CHROMEOS)
 337
 338   error_ = keys:: kErrorNotSupported;
 339   return false;
 340 }