Consolidate OnKeyEvent and InputMethod code.

chrome/browser/chromeos/login/screen_locker.cc

 // Copyright (c) 2011 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/login/screen_locker.h"
 
 #include <X11/extensions/XTest.h>
 #include <X11/keysym.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
@@ skipping 64 matching lines @@
                            public NotificationObserver {
  public:
   ScreenLockObserver() {
     registrar_.Add(this, NotificationType::LOGIN_USER_CHANGED,
                    NotificationService::AllSources());
   }
 
   // NotificationObserver overrides:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
-                       const NotificationDetails& details) {
+                       const NotificationDetails& details) OVERRIDE {
     if (type == NotificationType::LOGIN_USER_CHANGED) {
       // Register Screen Lock after login screen to make sure
       // we don't show the screen lock on top of the login screen by accident.
       if (chromeos::CrosLibrary::Get()->EnsureLoaded())
         chromeos::CrosLibrary::Get()->GetScreenLockLibrary()->AddObserver(this);
     }
   }
 
-  virtual void LockScreen(chromeos::ScreenLockLibrary* obj) {
+  virtual void LockScreen(chromeos::ScreenLockLibrary* obj) OVERRIDE {
     VLOG(1) << "In: ScreenLockObserver::LockScreen";
     SetupInputMethodsForScreenLocker();
     chromeos::ScreenLocker::Show();
   }
 
-  virtual void UnlockScreen(chromeos::ScreenLockLibrary* obj) {
+  virtual void UnlockScreen(chromeos::ScreenLockLibrary* obj) OVERRIDE {
     RestoreInputMethods();
     chromeos::ScreenLocker::Hide();
   }
 
-  virtual void UnlockScreenFailed(chromeos::ScreenLockLibrary* obj) {
+  virtual void UnlockScreenFailed(chromeos::ScreenLockLibrary* obj) OVERRIDE {
     chromeos::ScreenLocker::UnlockScreenFailed();
   }
 
  private:
   // Temporarily deactivates all input methods (e.g. Chinese, Japanese, Arabic)
   // since they are not necessary to input a login password. Users are still
   // able to use/switch active keyboard layouts (e.g. US qwerty, US dvorak,
   // French).
   void SetupInputMethodsForScreenLocker() {
     if (chromeos::CrosLibrary::Get()->EnsureLoaded() &&
@@ skipping 83 matching lines @@
 class LockWindow : public views::WidgetGtk {
  public:
   LockWindow()
       : views::WidgetGtk(views::WidgetGtk::TYPE_WINDOW),
         toplevel_focus_widget_(NULL) {
     EnableDoubleBuffer(true);
   }
 
   // GTK propagates key events from parents to children.
   // Make sure LockWindow will never handle key events.
-  virtual gboolean OnKeyEvent(GtkWidget* widget, GdkEventKey* event) {
+  virtual gboolean OnEventKey(GtkWidget* widget, GdkEventKey* event) OVERRIDE {
     // Don't handle key event in the lock window.
     return false;
   }
 
-  virtual void OnDestroy(GtkWidget* object) {
+  virtual void OnDestroy(GtkWidget* object) OVERRIDE {
     VLOG(1) << "OnDestroy: LockWindow destroyed";
     views::WidgetGtk::OnDestroy(object);
   }
 
-  virtual void ClearNativeFocus() {
+  virtual void ClearNativeFocus() OVERRIDE {
     DCHECK(toplevel_focus_widget_);
     gtk_widget_grab_focus(toplevel_focus_widget_);
   }
 
   // Sets the widget to move the focus to when clearning the native
   // widget's focus.
   void set_toplevel_focus_widget(GtkWidget* widget) {
     GTK_WIDGET_SET_FLAGS(widget, GTK_CAN_FOCUS);
     toplevel_focus_widget_ = widget;
   }
@@ skipping 17 matching lines @@
  public:
   explicit GrabWidgetRootView(chromeos::ScreenLockView* screen_lock_view)
       : screen_lock_view_(screen_lock_view),
         shutdown_button_(new chromeos::ShutdownButton()) {
     shutdown_button_->Init();
     AddChildView(screen_lock_view_);
     AddChildView(shutdown_button_);
   }
 
   // views::View implementation.
-  virtual void Layout() {
+  virtual void Layout() OVERRIDE {
     gfx::Size size = screen_lock_view_->GetPreferredSize();
     screen_lock_view_->SetBounds(0, 0, size.width(), size.height());
     shutdown_button_->LayoutIn(this);
   }
 
   // ScreenLocker::ScreenLockViewContainer implementation:
-  void SetScreenLockView(views::View* screen_lock_view) {
+  void SetScreenLockView(views::View* screen_lock_view) OVERRIDE {
     if (screen_lock_view_) {
       RemoveChildView(screen_lock_view_);
     }
     screen_lock_view_ =  screen_lock_view;
     if (screen_lock_view_) {
       AddChildViewAt(screen_lock_view_, 0);
     }
     Layout();
   }
 
@@ skipping 12 matching lines @@
       : views::WidgetGtk(views::WidgetGtk::TYPE_CHILD),
         screen_locker_(screen_locker),
         ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
         grab_failure_count_(0),
         kbd_grab_status_(GDK_GRAB_INVALID_TIME),
         mouse_grab_status_(GDK_GRAB_INVALID_TIME),
         signout_link_(NULL),
         shutdown_(NULL) {
   }
 
-  virtual void Show() {
+  virtual void Show() OVERRIDE {
     views::WidgetGtk::Show();
     signout_link_ =
         screen_locker_->GetViewByID(VIEW_ID_SCREEN_LOCKER_SIGNOUT_LINK);
     shutdown_ = screen_locker_->GetViewByID(VIEW_ID_SCREEN_LOCKER_SHUTDOWN);
     // These can be null in guest mode.
   }
 
   void ClearGtkGrab() {
     GtkWidget* current_grab_window;
     // Grab gtk input first so that the menu holding gtk grab will
     // close itself.
     gtk_grab_add(window_contents());
 
     // Make sure there is no gtk grab widget so that gtk simply propagates
     // an event.  This is necessary to allow message bubble and password
     // field, button to process events simultaneously. GTK
     // maintains grab widgets in a linked-list, so we need to remove
     // until it's empty.
     while ((current_grab_window = gtk_grab_get_current()) != NULL)
       gtk_grab_remove(current_grab_window);
   }
 
-  virtual gboolean OnKeyEvent(GtkWidget* widget, GdkEventKey* event) {
+  virtual gboolean OnEventKey(GtkWidget* widget, GdkEventKey* event) OVERRIDE {
     views::KeyEvent key_event(reinterpret_cast<GdkEvent*>(event));
     // This is a hack to workaround the issue crosbug.com/10655 due to
     // the limitation that a focus manager cannot handle views in
     // TYPE_CHILD WidgetGtk correctly.
     if (signout_link_ &&
         event->type == GDK_KEY_PRESS &&
         (event->keyval == GDK_Tab ||
          event->keyval == GDK_ISO_Left_Tab ||
          event->keyval == GDK_KP_Tab)) {
       DCHECK(shutdown_);
       bool reverse = event->state & GDK_SHIFT_MASK;
       if (reverse && signout_link_->HasFocus()) {
         shutdown_->RequestFocus();
         return true;
       }
       if (!reverse && shutdown_->HasFocus()) {
         signout_link_->RequestFocus();
         return true;
       }
     }
-    return views::WidgetGtk::OnKeyEvent(widget, event);
+    return views::WidgetGtk::OnEventKey(widget, event);
   }
 
-  virtual gboolean OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
+  virtual gboolean OnButtonPress(GtkWidget* widget,
+                                 GdkEventButton* event) OVERRIDE {
     WidgetGtk::OnButtonPress(widget, event);
     // Never propagate event to parent.
     return true;
   }
 
   // Try to grab all inputs. It initiates another try if it fails to
   // grab and the retry count is within a limit, or fails with CHECK.
   void TryGrabAllInputs();
 
   // This method tries to steal pointer/keyboard grab from other
   // client by sending events that will hopefully close menus or windows
   // that have the grab.
   void TryUngrabOtherClients();
 
  private:
-  virtual void HandleGtkGrabBroke() {
+  virtual void HandleGtkGrabBroke() OVERRIDE {
     // Input should never be stolen from ScreenLocker once it's
     // grabbed.  If this happens, it's a bug and has to be fixed. We
     // let chrome crash to get a crash report and dump, and
     // SessionManager will terminate the session to logout.
     CHECK_NE(GDK_GRAB_SUCCESS, kbd_grab_status_);
     CHECK_NE(GDK_GRAB_SUCCESS, mouse_grab_status_);
   }
 
   chromeos::ScreenLocker* screen_locker_;
   ScopedRunnableMethodFactory<GrabWidget> task_factory_;
@@ skipping 105 matching lines @@
 class ScreenLockerBackgroundView
     : public chromeos::BackgroundView,
       public chromeos::ScreenLocker::ScreenLockViewContainer {
  public:
   ScreenLockerBackgroundView(views::WidgetGtk* lock_widget,
                              views::View* screen_lock_view)
       : lock_widget_(lock_widget),
         screen_lock_view_(screen_lock_view) {
   }
 
-  virtual ScreenMode GetScreenMode() const {
+  virtual ScreenMode GetScreenMode() const OVERRIDE {
     return kScreenLockerMode;
   }
 
-  virtual void Layout() {
+  virtual void Layout() OVERRIDE {
     chromeos::BackgroundView::Layout();
     gfx::Rect screen = bounds();
     if (screen_lock_view_) {
       gfx::Size size = screen_lock_view_->GetPreferredSize();
       gfx::Point origin((screen.width() - size.width()) / 2,
                         (screen.height() - size.height()) / 2);
       gfx::Size widget_size(screen.size());
       widget_size.Enlarge(-origin.x(), -origin.y());
       lock_widget_->SetBounds(gfx::Rect(origin, widget_size));
     } else {
       // No password entry. Move the lock widget to off screen.
       lock_widget_->SetBounds(gfx::Rect(-100, -100, 1, 1));
     }
   }
 
   // ScreenLocker::ScreenLockViewContainer implementation:
-  void SetScreenLockView(views::View* screen_lock_view) {
+  virtual void SetScreenLockView(views::View* screen_lock_view) OVERRIDE {
     screen_lock_view_ =  screen_lock_view;
     Layout();
   }
 
  private:
   views::WidgetGtk* lock_widget_;
 
   views::View* screen_lock_view_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockerBackgroundView);
@@ skipping 11 matching lines @@
 class MouseEventRelay : public MessageLoopForUI::Observer {
  public:
   MouseEventRelay(GdkWindow* src, GdkWindow* dest)
       : src_(src),
         dest_(dest),
         initialized_(false) {
     DCHECK(src_);
     DCHECK(dest_);
   }
 
-  virtual void WillProcessEvent(GdkEvent* event) {}
+  virtual void WillProcessEvent(GdkEvent* event) OVERRIDE {}
 
-  virtual void DidProcessEvent(GdkEvent* event) {
+  virtual void DidProcessEvent(GdkEvent* event) OVERRIDE {
     if (event->any.window != src_)
       return;
     if (!initialized_) {
       gint src_x, src_y, dest_x, dest_y, width, height, depth;
       gdk_window_get_geometry(dest_, &dest_x, &dest_y, &width, &height, &depth);
       // wait to compute offset until the info bubble widget's location
       // is available.
       if (dest_x < 0 || dest_y < 0)
         return;
       gdk_window_get_geometry(src_, &src_x, &src_y, &width, &height, &depth);
@@ skipping 36 matching lines @@
 // A event observer used to unlock the screen upon user's action
 // without asking password. Used in BWSI and auto login mode.
 // TODO(oshima): consolidate InputEventObserver and LockerInputEventObserver.
 class InputEventObserver : public MessageLoopForUI::Observer {
  public:
   explicit InputEventObserver(ScreenLocker* screen_locker)
       : screen_locker_(screen_locker),
         activated_(false) {
   }
 
-  virtual void WillProcessEvent(GdkEvent* event) {
+  virtual void WillProcessEvent(GdkEvent* event) OVERRIDE {
     if ((event->type == GDK_KEY_PRESS ||
          event->type == GDK_BUTTON_PRESS ||
          event->type == GDK_MOTION_NOTIFY) &&
         !activated_) {
       activated_ = true;
       std::string not_used_string;
       GaiaAuthConsumer::ClientLoginResult not_used;
       screen_locker_->OnLoginSuccess(not_used_string,
                                      not_used_string,
                                      not_used,
                                      false);
     }
   }
 
-  virtual void DidProcessEvent(GdkEvent* event) {
+  virtual void DidProcessEvent(GdkEvent* event) OVERRIDE {
   }
 
  private:
   chromeos::ScreenLocker* screen_locker_;
 
   bool activated_;
 
   DISALLOW_COPY_AND_ASSIGN(InputEventObserver);
 };
 
 // A event observer used to show the screen locker upon
 // user action: mouse or keyboard interactions.
 // TODO(oshima): this has to be disabled while authenticating.
 class LockerInputEventObserver : public MessageLoopForUI::Observer {
  public:
   explicit LockerInputEventObserver(ScreenLocker* screen_locker)
       : screen_locker_(screen_locker),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             timer_(base::TimeDelta::FromSeconds(kScreenSaverIdleTimeout), this,
                    &LockerInputEventObserver::StartScreenSaver)) {
   }
 
-  virtual void WillProcessEvent(GdkEvent* event) {
+  virtual void WillProcessEvent(GdkEvent* event) OVERRIDE {
     if ((event->type == GDK_KEY_PRESS ||
          event->type == GDK_BUTTON_PRESS ||
          event->type == GDK_MOTION_NOTIFY)) {
       timer_.Reset();
       screen_locker_->StopScreenSaver();
     }
   }
 
-  virtual void DidProcessEvent(GdkEvent* event) {
+  virtual void DidProcessEvent(GdkEvent* event) OVERRIDE {
   }
 
  private:
   void StartScreenSaver() {
     screen_locker_->StartScreenSaver();
   }
 
   chromeos::ScreenLocker* screen_locker_;
   base::DelayTimer<LockerInputEventObserver> timer_;
 
@@ skipping 488 matching lines @@
 
 bool ScreenLocker::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     StartScreenSaver();
     return true;
   }
   return false;
 }
 
 }  // namespace chromeos