Select-to-speak event handler

chrome/browser/chromeos/accessibility/select_to_speak_event_handler.cc

+// Copyright 2016 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 "chrome/browser/chromeos/accessibility/select_to_speak_event_handler.h"
+
+#include "ash/shell.h"
+#include "chrome/browser/ui/aura/accessibility/automation_manager_aura.h"
+#include "ui/aura/window.h"
+#include "ui/display/display.h"
+#include "ui/events/event.h"
+#include "ui/views/focus/view_storage.h"
+#include "ui/views/view.h"
+#include "ui/views/widget/widget.h"
+
+namespace chromeos {
+
+SelectToSpeakEventHandler::SelectToSpeakEventHandler() {
+  if (ash::Shell::HasInstance())
+    ash::Shell::GetInstance()->AddPreTargetHandler(this);
+}
+
+SelectToSpeakEventHandler::~SelectToSpeakEventHandler() {
+  if (ash::Shell::HasInstance())
+    ash::Shell::GetInstance()->RemovePreTargetHandler(this);
+}
+
+void SelectToSpeakEventHandler::OnKeyEvent(ui::KeyEvent* event) {
+  if (event->key_code() == ui::VKEY_LWIN) {
+    if (event->type() == ui::ET_KEY_PRESSED) {
+      state_ = SEARCH_DOWN;
+    } else if (event->type() == ui::ET_KEY_RELEASED) {
+      if (state_ == CAPTURING) {
+        SendCancelAXEvent();
+        CancelEvent(event);
+        state_ = WAIT_FOR_MOUSE_RELEASE;
+      } else if (state_ == MOUSE_RELEASED) {
+        CancelEvent(event);
+        state_ = INACTIVE;

[David Tseng, 2016/11/11 19:18:30]

Should you set state to inactive for all other key release events (or at least
search released)? For example, if I pressed search and an arrow key. We'd remain
in the search down state, right?

[dmazzoni, 2016/11/14 22:11:41]

Great idea. Done, and added a new test for this case.

+      }
+    }
+  }
+}
+
+void SelectToSpeakEventHandler::OnMouseEvent(ui::MouseEvent* event) {
+  if (state_ == INACTIVE)
+    return;
+
+  if ((state_ == SEARCH_DOWN || state_ == MOUSE_RELEASED) &&

[David Tseng, 2016/11/11 19:18:30]

How do we go from mouse released -> mouse pressed = capturing?

[dmazzoni, 2016/11/14 22:11:42]

This is to support the user holding down search and
clicking more than once, does that make sense?
The mouse released state means that the mouse was released
but Search was still down. I tried to explain this in the
header file.

+      event->type() == ui::ET_MOUSE_PRESSED) {
+    state_ = CAPTURING;
+  }
+
+  if (state_ == WAIT_FOR_MOUSE_RELEASE &&
+      event->type() == ui::ET_MOUSE_RELEASED) {
+    CancelEvent(event);
+    state_ = INACTIVE;
+    return;
+  }
+
+  if (state_ != CAPTURING)

[David Tseng, 2016/11/11 19:18:30]

Rather than one state, I think it would be a lot clearer to have:
- a boolean search_down that tracks whether tha search key is down or not
- mouse down

capturing = serach_down && mouse_down

[dmazzoni, 2016/11/14 22:11:41]

That doesn't handle all of the current states. For example it doesn't handle the
case where Search is still down, mouse released vs search held down but no click
yet. The difference is that if the user has pressed the mouse, we want to handle
the release of the Search key.

The problem with bools is that if we had enough bools to express all of
the different states we need, there would be some permutations that make
no sense. Having a discrete number of states makes it easier to reason
about every possible transition.

+    return;
+
+  // If we're in the capturing state, send accessibility events to
+  // the Select-to-speak extension based on the mouse event.
+  // First, figure out what event to send.
+  ui::AXEvent ax_event = ui::AX_EVENT_NONE;
+  switch (event->type()) {
+    case ui::ET_MOUSE_PRESSED:
+      ax_event = ui::AX_EVENT_MOUSE_PRESSED;
+      break;
+    case ui::ET_MOUSE_DRAGGED:
+      ax_event = ui::AX_EVENT_MOUSE_DRAGGED;
+      break;
+    case ui::ET_MOUSE_RELEASED:
+      state_ = MOUSE_RELEASED;
+      ax_event = ui::AX_EVENT_MOUSE_RELEASED;
+      break;
+    case ui::ET_MOUSE_MOVED:
+    case ui::ET_MOUSE_ENTERED:
+    case ui::ET_MOUSE_EXITED:
+      ax_event = ui::AX_EVENT_MOUSE_MOVED;
+      break;
+    default:
+      return;
+  }
+
+  CancelEvent(event);
+
+  // Find the View to post the accessibility event on.
+  aura::Window* event_target = static_cast<aura::Window*>(event->target());
+  aura::Window* hit_window = event_target;
+  if (!hit_window)
+    return;
+
+  views::Widget* hit_widget = views::Widget::GetWidgetForNativeView(hit_window);
+  while (!hit_widget) {
+    hit_window = hit_window->parent();
+    if (!hit_window)
+      break;
+
+    hit_widget = views::Widget::GetWidgetForNativeView(hit_window);
+  }
+
+  if (!hit_window || !hit_widget)
+    return;
+
+  gfx::Point window_location = event->location();
+  aura::Window::ConvertPointToTarget(event_target, hit_window,
+                                     &window_location);
+
+  views::View* root_view = hit_widget->GetRootView();
+  views::View* hit_view = root_view->GetEventHandlerForPoint(window_location);
+
+  if (hit_view) {
+    // Send the accessibility event, then save the view so we can post the
+    // cancel event on the same view if possible.
+    hit_view->NotifyAccessibilityEvent(ax_event, true);
+    if (!last_view_storage_id_) {
+      last_view_storage_id_ =
+          views::ViewStorage::GetInstance()->CreateStorageID();
+    }
+    views::ViewStorage::GetInstance()->RemoveView(last_view_storage_id_);
+    views::ViewStorage::GetInstance()->StoreView(last_view_storage_id_,
+                                                 hit_view);
+  }
+}
+
+void SelectToSpeakEventHandler::CancelEvent(ui::Event* event) {
+  if (event->cancelable()) {
+    event->SetHandled();
+    event->StopPropagation();
+  }
+}
+
+void SelectToSpeakEventHandler::SendCancelAXEvent() {
+  // If the user releases Search while the button is still down, cancel
+  // the Select-to-speak gesture. Try to post it on the same View that
+  // was last targeted, but if that's impossible, post it on the desktop.
+  views::View* last_view =
+      last_view_storage_id_
+          ? views::ViewStorage::GetInstance()->RetrieveView(
+                last_view_storage_id_)
+          : nullptr;
+  if (last_view) {
+    last_view->NotifyAccessibilityEvent(ui::AX_EVENT_MOUSE_CANCELED, true);
+  } else {
+    AutomationManagerAura::GetInstance()->HandleEvent(
+        nullptr, nullptr, ui::AX_EVENT_MOUSE_CANCELED);
+  }
+}
+
+}  // namespace chromeos