Proposed alternative for supporting ChromeVox keyboard commands.

chrome/browser/chromeos/accessibility/spoken_feedback_event_rewriter.cc

+// Copyright 2015 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/spoken_feedback_event_rewriter.h"
+
+#include <string>
+
+#include "base/values.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/extensions/api/commands/commands_handler.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_registry.h"
+#include "ui/events/event.h"
+
+SpokenFeedbackEventRewriter::SpokenFeedbackEventRewriter(
+    SpokenFeedbackEventRewriterDelegate* delegate)
+    : modifiers_down_(0), delegate_(delegate) {
+}
+
+SpokenFeedbackEventRewriter::~SpokenFeedbackEventRewriter() {
+}
+
+ui::EventRewriteStatus SpokenFeedbackEventRewriter::RewriteEvent(
+    const ui::Event& event,
+    scoped_ptr<ui::Event>* new_event) {
+  if ((!delegate_ && !IsSpokenFeedbackEnabled()) ||
+      !delegate_->IsSpokenFeedbackEnabled())
+    return ui::EVENT_REWRITE_CONTINUE;
+
+  if ((event.type() != ui::ET_KEY_PRESSED &&
+       event.type() != ui::ET_KEY_RELEASED)) {
+    LOG(ERROR) << "ret!" << g_browser_process->profile_manager();
+    return ui::EVENT_REWRITE_CONTINUE;
+  }
+
+  const ui::KeyEvent key_event = static_cast<const ui::KeyEvent&>(event);
+  if (event.type() == ui::ET_KEY_RELEASED) {
+    if (modifiers_down_) {
+      if (key_event.key_code() == ui::VKEY_SHIFT &&
+          ui::EF_SHIFT_DOWN & modifiers_down_) {
+        modifiers_down_ &= ~ui::EF_SHIFT_DOWN;
+        return ui::EVENT_REWRITE_DISCARD;
+      } else if (key_event.key_code() == ui::VKEY_LWIN &&
+                 modifiers_down_ & ui::EF_COMMAND_DOWN) {
+        modifiers_down_ &= ~ui::EF_COMMAND_DOWN;
+        return ui::EVENT_REWRITE_DISCARD;
+      } else if (key_event.key_code() == ui::VKEY_CONTROL &&
+                 modifiers_down_ & ui::EF_CONTROL_DOWN) {
+        modifiers_down_ &= ~ui::EF_CONTROL_DOWN;
+        return ui::EVENT_REWRITE_DISCARD;
+      }
+      std::vector<int>::iterator it =
+          std::find(captured_key_codes_.begin(), captured_key_codes_.end(),
+                    key_event.key_code());
+      if (it != captured_key_codes_.end()) {
+        captured_key_codes_.erase(it);
+        return ui::EVENT_REWRITE_DISCARD;
+      }
+    }
+    return ui::EVENT_REWRITE_CONTINUE;
+  }
+
+  bool success = false;
+  if (delegate_)
+    success = delegate_->DispatchKeyToChromeVox(key_event);
+  else
+    success = DispatchKeyToChromeVox(key_event);
+
+  if (success) {
+    captured_key_codes_.push_back(key_event.key_code());
+    modifiers_down_ = key_event.flags();
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+  return ui::EVENT_REWRITE_CONTINUE;
+}
+
+ui::EventRewriteStatus SpokenFeedbackEventRewriter::NextDispatchEvent(
+    const ui::Event& last_event,
+    scoped_ptr<ui::Event>* new_event) {
+  return ui::EVENT_REWRITE_CONTINUE;
+}
+
+bool SpokenFeedbackEventRewriter::IsSpokenFeedbackEnabled() const {
+  return true;
+}
+
+bool SpokenFeedbackEventRewriter::DispatchKeyToChromeVox(
+    ui::KeyEvent key_event) {
+  if (!g_browser_process->profile_manager())
+    return false;
+
+  content::BrowserContext* context =
+      g_browser_process->profile_manager()->GetLastUsedProfile();
+
+  const extensions::Extension* extension =
+      extensions::ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
+          extension_misc::kChromeVoxExtensionId);
+  if (!extension)
+    return false;
+
+  extensions::EventRouter* event_router = extensions::EventRouter::Get(context);
+  if (!event_router->ExtensionHasEventListener(
+          extension_misc::kChromeVoxExtensionId, "commands.onCommand"))
+    return false;
+
+  const extensions::CommandMap* commands =
+      extensions::CommandsInfo::GetNamedCommands(extension);
+  if (!commands)
+    return false;
+
+  int modifiers = key_event.flags() & ui::EF_ALL_MODIFIERS;
+  std::string command_name;
+  for (extensions::CommandMap::const_iterator iter = commands->begin();
+       iter != commands->end(); ++iter) {
+    int command_modifiers =
+        iter->second.accelerator().modifiers() & ui::EF_ALL_MODIFIERS;
+    if (iter->second.accelerator().key_code() == key_event.key_code() &&
+        command_modifiers == modifiers)
+      command_name = iter->second.command_name();
+  }
+
+  if (command_name.empty())
+    return false;
+
+  scoped_ptr<base::ListValue> args(new base::ListValue());
+  args->Append(new base::StringValue(command_name));
+
+  scoped_ptr<extensions::Event> extension_event(
+      new extensions::Event("commands.onCommand", args.Pass()));
+  extension_event->restrict_to_browser_context = context;
+
+  event_router->DispatchEventToExtension(extension_misc::kChromeVoxExtensionId,
+                                         extension_event.Pass());
+
+  return true;
+}