mustash: Use ui::chromeos::EventRewriter in mus

ui/keyboard/keyboard_util.cc

 // Copyright (c) 2013 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 "ui/keyboard/keyboard_util.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string16.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_base.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/ime/text_input_flags.h"
-#include "ui/events/event_processor.h"
+#include "ui/events/event_sink.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "ui/keyboard/keyboard_ui.h"
 #include "ui/keyboard/scoped_keyboard_disabler.h"
 
 namespace {
 
 const char kKeyDown[] ="keydown";
 const char kKeyUp[] = "keyup";
 
 void SendProcessKeyEvent(ui::EventType type,
                          aura::WindowTreeHost* host) {
   ui::KeyEvent event(type, ui::VKEY_PROCESSKEY, ui::DomCode::NONE,
                      ui::EF_IS_SYNTHESIZED, ui::DomKey::PROCESS,
                      ui::EventTimeForNow());
   ui::EventDispatchDetails details =
-      host->event_processor()->OnEventFromSource(&event);
+      host->event_sink()->OnEventFromSource(&event);
   CHECK(!details.dispatcher_destroyed);
 }
 
 base::LazyInstance<base::Time>::DestructorAtExit g_keyboard_load_time_start =
     LAZY_INSTANCE_INITIALIZER;
 
 bool g_accessibility_keyboard_enabled = false;
 
 bool g_hotrod_keyboard_enabled = false;
 
@@ skipping 207 matching lines @@
   // First deal with the x movement.
   if (domcodex != ui::DomCode::NONE) {
     ui::KeyboardCode codex = ui::VKEY_UNKNOWN;
     ui::DomKey domkeyx = ui::DomKey::NONE;
     ignore_result(DomCodeToUsLayoutDomKey(domcodex, ui::EF_NONE, &domkeyx,
                                           &codex));
     ui::KeyEvent press_event(ui::ET_KEY_PRESSED, codex, domcodex,
                              modifier_flags, domkeyx,
                              ui::EventTimeForNow());
     ui::EventDispatchDetails details =
-        host->event_processor()->OnEventFromSource(&press_event);
+        host->event_sink()->OnEventFromSource(&press_event);
     CHECK(!details.dispatcher_destroyed);
     ui::KeyEvent release_event(ui::ET_KEY_RELEASED, codex, domcodex,
                                modifier_flags, domkeyx,
                                ui::EventTimeForNow());
-    details = host->event_processor()->OnEventFromSource(&release_event);
+    details = host->event_sink()->OnEventFromSource(&release_event);
     CHECK(!details.dispatcher_destroyed);
   }
 
   // Then deal with the y movement.
   if (domcodey != ui::DomCode::NONE) {
     ui::KeyboardCode codey = ui::VKEY_UNKNOWN;
     ui::DomKey domkeyy = ui::DomKey::NONE;
     ignore_result(DomCodeToUsLayoutDomKey(domcodey, ui::EF_NONE, &domkeyy,
                                           &codey));
     ui::KeyEvent press_event(ui::ET_KEY_PRESSED, codey, domcodey,
                              modifier_flags, domkeyy,
                              ui::EventTimeForNow());
     ui::EventDispatchDetails details =
-        host->event_processor()->OnEventFromSource(&press_event);
+        host->event_sink()->OnEventFromSource(&press_event);
     CHECK(!details.dispatcher_destroyed);
     ui::KeyEvent release_event(ui::ET_KEY_RELEASED, codey, domcodey,
                                modifier_flags, domkeyy,
                                ui::EventTimeForNow());
-    details = host->event_processor()->OnEventFromSource(&release_event);
+    details = host->event_sink()->OnEventFromSource(&release_event);
     CHECK(!details.dispatcher_destroyed);
   }
   return true;
 }
 
 bool SendKeyEvent(const std::string type,
                   int key_value,
                   int key_code,
                   std::string key_name,
                   int modifiers,
@@ skipping 46 matching lines @@
     CHECK(dom_code != ui::DomCode::NONE);
     ui::KeyEvent event(
         event_type,
         code,
         dom_code,
         modifiers);
     if (input_method) {
       input_method->DispatchKeyEvent(&event);
     } else {
       ui::EventDispatchDetails details =
-          host->event_processor()->OnEventFromSource(&event);
+          host->event_sink()->OnEventFromSource(&event);
       CHECK(!details.dispatcher_destroyed);
     }
   }
   return true;
 }
 
 void MarkKeyboardLoadStarted() {
   if (!g_keyboard_load_time_start.Get().ToInternalValue())
     g_keyboard_load_time_start.Get() = base::Time::Now();
 }
@@ skipping 23 matching lines @@
       "VirtualKeyboard.KeyboardControlEvent",
       event,
       keyboard::KEYBOARD_CONTROL_MAX);
 }
 
 void SetOverscrollEnabledWithAccessibilityKeyboard(bool enabled) {
   g_overscroll_enabled_with_accessibility_keyboard = enabled;
 }
 
 }  // namespace keyboard