Refactor Select-to-speak so that mouse events are forwarded to the extension.

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 "base/logging.h"
-#include "chrome/browser/speech/tts_controller.h"
-#include "chrome/browser/ui/aura/accessibility/automation_manager_aura.h"
-#include "chrome/common/extensions/api/automation_api_constants.h"
+#include "chrome/browser/chromeos/accessibility/event_handler_common.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/browser_thread.h"
-#include "ui/accessibility/ax_tree_id_registry.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "third_party/WebKit/public/platform/WebMouseEvent.h"
+#include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
+#include "ui/events/blink/web_input_event.h"
 #include "ui/events/event.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace chromeos {
 
+namespace {
+
+gfx::Point GetScreenLocationFromEvent(const ui::LocatedEvent& event) {
+  aura::Window* root =
+      static_cast<aura::Window*>(event.target())->GetRootWindow();
+  aura::client::ScreenPositionClient* spc =
+      aura::client::GetScreenPositionClient(root);
+  if (!spc)
+    return event.root_location();
+
+  gfx::Point screen_location(event.root_location());
+  spc->ConvertPointToScreen(root, &screen_location);
+  return screen_location;
+}
+}  // namespace
+
 SelectToSpeakEventHandler::SelectToSpeakEventHandler() {
   if (ash::Shell::HasInstance())
     ash::Shell::Get()->GetPrimaryRootWindow()->AddPreTargetHandler(this);
 }
 
 SelectToSpeakEventHandler::~SelectToSpeakEventHandler() {
   if (ash::Shell::HasInstance())
     ash::Shell::Get()->GetPrimaryRootWindow()->RemovePreTargetHandler(this);
 }
 
+void SelectToSpeakEventHandler::CaptureForwardedEventsForTesting(
+    SelectToSpeakForwardedEventDelegateForTesting* delegate) {
+  event_delegate_for_testing_ = delegate;
+}
+
 void SelectToSpeakEventHandler::OnKeyEvent(ui::KeyEvent* event) {
   DCHECK(event);
 
   // We can only call TtsController on the UI thread, make sure we
   // don't ever try to run this code on some other thread.
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   ui::KeyboardCode key_code = event->key_code();
-
-  // Stop speech when the user taps and releases Control or Search
-  // without pressing any other keys along the way.
-  if (state_ != MOUSE_RELEASED && event->type() == ui::ET_KEY_RELEASED &&
-      (key_code == ui::VKEY_CONTROL || key_code == ui::VKEY_LWIN) &&
-      keys_pressed_together_.find(key_code) != keys_pressed_together_.end() &&
-      keys_pressed_together_.size() == 1) {
-    TtsController::GetInstance()->Stop();
-  }
-
-  // Update keys_currently_down_ and keys_pressed_together_.
-  if (event->type() == ui::ET_KEY_PRESSED) {
-    keys_currently_down_.insert(key_code);
-    keys_pressed_together_.insert(key_code);
-  } else if (event->type() == ui::ET_KEY_RELEASED) {
-    keys_currently_down_.erase(key_code);
-    if (keys_currently_down_.empty())
-      keys_pressed_together_.clear();
-  }
+  bool cancel_event = false;
 
   // Update the state when pressing and releasing the Search key (VKEY_LWIN).
   if (key_code == ui::VKEY_LWIN) {
     if (event->type() == ui::ET_KEY_PRESSED && state_ == INACTIVE) {
       state_ = SEARCH_DOWN;
     } else if (event->type() == ui::ET_KEY_RELEASED) {
       if (state_ == CAPTURING) {
-        SendCancelAXEvent();
-        CancelEvent(event);
+        cancel_event = true;
         state_ = WAIT_FOR_MOUSE_RELEASE;
       } else if (state_ == MOUSE_RELEASED) {
-        CancelEvent(event);
+        cancel_event = true;
         state_ = INACTIVE;
       }
     }
   } else if (state_ == SEARCH_DOWN) {
     state_ = INACTIVE;

[David Tseng, 2017/05/16 15:54:39]

Almost there. Can we move all of this state logic into the extension as well? We
would always cancel events by default and re-inject if needed.

[dmazzoni, 2017/05/16 18:23:48]

As discussed, I'd like to avoid re-injecting due to problems we
experienced doing that with ChromeVox, and also due to the added
latency, since I'd like S2S to not add any overhead when not
explicitly used.

   }
+
+  // Forward the key to the extension.
+  extensions::ExtensionHost* host =
+      GetAccessibilityExtensionHost(extension_misc::kSelectToSpeakExtensionId);
+  if (host)
+    ForwardKeyToExtension(*event, host);
+
+  if (cancel_event)
+    CancelEvent(event);
 }
 
 void SelectToSpeakEventHandler::OnMouseEvent(ui::MouseEvent* event) {
   DCHECK(event);
   if (state_ == INACTIVE)
     return;
 
   if ((state_ == SEARCH_DOWN || state_ == MOUSE_RELEASED) &&
       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)
     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:
+  if (event->type() == ui::ET_MOUSE_RELEASED)
+    state_ = MOUSE_RELEASED;
+
+  // If we're in the capturing state, forward the mouse event to
+  // select-to-speak.
+  if (event_delegate_for_testing_) {
+    event_delegate_for_testing_->OnForwardEventToSelectToSpeakExtension(*event);
+  } else {
+    extensions::ExtensionHost* host = GetAccessibilityExtensionHost(
+        extension_misc::kSelectToSpeakExtensionId);
+    if (!host)
       return;
+
+    content::RenderViewHost* rvh = host->render_view_host();
+    if (!rvh)
+      return;
+
+    const blink::WebMouseEvent web_event =
+        ui::MakeWebMouseEvent(*event, base::Bind(&GetScreenLocationFromEvent));
+    rvh->GetWidget()->ForwardMouseEvent(web_event);
   }
 
   CancelEvent(event);
-
-  ui::AXTreeIDRegistry* registry = ui::AXTreeIDRegistry::GetInstance();
-  ui::AXHostDelegate* delegate =
-      registry->GetHostDelegate(extensions::api::automation::kDesktopTreeID);
-  if (delegate) {
-    ui::AXActionData action;
-    action.action = ui::AX_ACTION_HIT_TEST;
-    action.target_point = event->root_location();
-    action.hit_test_event_to_fire = ax_event;
-    delegate->PerformAction(action);
-  }
 }
 
 void SelectToSpeakEventHandler::CancelEvent(ui::Event* event) {
   DCHECK(event);
   if (event->cancelable()) {
     event->SetHandled();
     event->StopPropagation();
   }
 }
 
-void SelectToSpeakEventHandler::SendCancelAXEvent() {
-  AutomationManagerAura::GetInstance()->HandleEvent(
-      nullptr, nullptr, ui::AX_EVENT_MOUSE_CANCELED);
-}
-
 }  // namespace chromeos