Proposed alternative for supporting ChromeVox keyboard commands.

chrome/browser/chromeos/accessibility/spoken_feedback_event_rewriter.cc

Index: chrome/browser/chromeos/accessibility/spoken_feedback_event_rewriter.cc
diff --git a/chrome/browser/chromeos/accessibility/spoken_feedback_event_rewriter.cc b/chrome/browser/chromeos/accessibility/spoken_feedback_event_rewriter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0e4237e8ce0f3b335a24b58a7f7181060566e663
--- /dev/null
+++ b/chrome/browser/chromeos/accessibility/spoken_feedback_event_rewriter.cc
@@ -0,0 +1,120 @@
+// 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"
+
+bool SpokenFeedbackEventRewriterDelegate::IsSpokenFeedbackEnabled() const {
+  return true;
+}
+
+bool SpokenFeedbackEventRewriterDelegate::DispatchKeyToChromeVox(
+    ui::KeyEvent key_event) {
+  int kAllModifiers = ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
+                      ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN;
+
+  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() & kAllModifiers;
+  std::string command_name;
+  for (extensions::CommandMap::const_iterator iter = commands->begin();
+       iter != commands->end(); ++iter) {
+    int command_modifiers =
+        iter->second.accelerator().modifiers() & kAllModifiers;
+    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;
+}
+
+SpokenFeedbackEventRewriter::SpokenFeedbackEventRewriter(
+    SpokenFeedbackEventRewriterDelegate* delegate)
+    : delegate_(delegate) {
+  if (!delegate_)
+    delegate_ = &default_delegate_;
+}
+
+SpokenFeedbackEventRewriter::~SpokenFeedbackEventRewriter() {
+}
+
+ui::EventRewriteStatus SpokenFeedbackEventRewriter::RewriteEvent(
+    const ui::Event& event,
+    scoped_ptr<ui::Event>* new_event) {
+  if (!delegate_->IsSpokenFeedbackEnabled())
+    return ui::EVENT_REWRITE_CONTINUE;
+
+  if ((event.type() != ui::ET_KEY_PRESSED &&
+       event.type() != ui::ET_KEY_RELEASED))
+    return ui::EVENT_REWRITE_CONTINUE;
+
+  const ui::KeyEvent key_event = static_cast<const ui::KeyEvent&>(event);
+  if (event.type() == ui::ET_KEY_RELEASED) {
+    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;
+  }
+
+  if (delegate_->DispatchKeyToChromeVox(key_event)) {

[stevenjb, 2015/06/25 16:10:14]

We are seeing a crash in DispatchKeyToChromeVox when it calls
ProfileManager::GetLastUsedProfile when called from here. Here is a crash:

https://00e9e64bac9e55b1ad3bc989f7fe6755e50c3d830bde6537f1-apidata.googleuser...

I am going to file an issue for this, and will try to use cbuildbot to confirm,
but if you can think how this might happen after the Profile has been destroyed,
we should revert this.

[David Tseng, 2015/06/25 16:44:06]

According to the stack, it looks like the call to
ProfileManager::GetLastUsedProfile eventually calls
ProfileManager::CreateAndInitializeProfile which causes an out of memory error.
Oshima, any comments on this particular theory?

[oshima, 2015/06/25 17:02:37]

I couldn't access the stack info. Can you post it here?

[oshima, 2015/06/25 17:13:36]

My guess is that this is called before profiles are fully loaded.

I don't know why CreateAndInitializeProfile crashes, but I think you shouldn't
call this unless
profiles are loaded anyway. There is NOTIFICATION_PROFILE_ADDED notification, so
you can try that.
(I'm not sure if this is called for login profile. you may need different way to
wire this up if not)

+    captured_key_codes_.push_back(key_event.key_code());
+    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;
+}