Screen Locker fixes

chrome/browser/chromeos/login/screen_locker.cc

 // Copyright (c) 2010 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 <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 #include <string>
 #include <vector>
 #include <X11/extensions/XTest.h>
 #include <X11/keysym.h>
 // Evil hack to undo X11 evil #define. See crosbug.com/
 #undef Status
 
 #include "app/l10n_util.h"
 #include "base/command_line.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/background_view.h"
 #include "chrome/browser/chromeos/login/login_performer.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/message_bubble.h"
 #include "chrome/browser/chromeos/login/screen_lock_view.h"
 #include "chrome/browser/chromeos/login/shutdown_button.h"
 #include "chrome/browser/chromeos/system_key_event_listener.h"
 #include "chrome/browser/chromeos/wm_ipc.h"
+#include "chrome/browser/chromeos/view_ids.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "third_party/cros/chromeos_wm_ipc_enums.h"
@@ skipping 152 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 OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
+  virtual gboolean OnKeyEvent(GtkWidget* widget, GdkEventKey* event) {
     // Don't handle key event in the lock window.
     return false;
   }
-
-  virtual gboolean OnKeyRelease(GtkWidget* widget, GdkEventKey* event) {
-    // Don't handle key event in the lock window.
-    return false;
-  }
 
   virtual void OnDestroy(GtkWidget* object) {
     VLOG(1) << "OnDestroy: LockWindow destroyed";
     views::WidgetGtk::OnDestroy(object);
   }
 
   virtual void ClearNativeFocus() {
     DCHECK(toplevel_focus_widget_);
     gtk_widget_grab_focus(toplevel_focus_widget_);
   }
@@ skipping 59 matching lines @@
 
 // A child widget that grabs both keyboard and pointer input.
 class GrabWidget : public views::WidgetGtk {
  public:
   explicit GrabWidget(chromeos::ScreenLocker* screen_locker)
       : 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) {
+        mouse_grab_status_(GDK_GRAB_INVALID_TIME),
+        signout_link_(NULL),
+        shutdown_(NULL) {
   }
 
   virtual void Show() {
     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) {
+    views::KeyEvent key_event(event);
+    // This is a hack to workaround the issue crosbug.com/10655 due to
+    // the limitatino that a focus manager cannot handle views in

[whywhat, 2011/01/24 19:27:56]

nit: limitatino -> limitation

[oshima, 2011/01/24 20:24:31]

Done.

+    // TYPE_CHILD WidgetGtk correctly.

[whywhat, 2011/01/24 19:27:56]

Should we report a bug about that? Is there one already?

[oshima, 2011/01/24 20:24:31]

I believe this is by design. I'll task to Jay about this, but since we're moving
towards DOMUI and getting this work correctly with Widget is very tricky (as
they're different views hierachy), it may not worth it.

+    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()) {

[whywhat, 2011/01/24 19:27:56]

Will pressing Tab cycle through the links? As I read it, it doesn't

[oshima, 2011/01/24 20:24:31]

It moves focus to shutdown if you press shift-tab when focus is on link.

+        shutdown_->RequestFocus();
+        return true;
+      }
+      if (!reverse && shutdown_->HasFocus()) {
+        signout_link_->RequestFocus();
+        return true;
+      }
+    }
+    return views::WidgetGtk::OnKeyEvent(widget, event);
+  }
+
   virtual gboolean OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
     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();
 
@@ skipping 15 matching lines @@
 
   chromeos::ScreenLocker* screen_locker_;
   ScopedRunnableMethodFactory<GrabWidget> task_factory_;
 
   // The number times the widget tried to grab all focus.
   int grab_failure_count_;
   // Status of keyboard and mouse grab.
   GdkGrabStatus kbd_grab_status_;
   GdkGrabStatus mouse_grab_status_;
 
+  views::View* signout_link_;
+  views::View* shutdown_;
+
   DISALLOW_COPY_AND_ASSIGN(GrabWidget);
 };
 
 void GrabWidget::TryGrabAllInputs() {
   // Grab x server so that we can atomically grab and take
   // action when grab fails.
   gdk_x11_grab_server();
   if (kbd_grab_status_ != GDK_GRAB_SUCCESS) {
     kbd_grab_status_ = gdk_keyboard_grab(window_contents()->window, FALSE,
                                          GDK_CURRENT_TIME);
@@ skipping 550 matching lines @@
       BubbleBorder::BOTTOM_RIGHT : BubbleBorder::BOTTOM_LEFT);
 }
 
 void ScreenLocker::OnGrabInputs() {
   DVLOG(1) << "OnGrabInputs";
   input_grabbed_ = true;
   if (drawn_)
     ScreenLockReady();
 }
 
+views::View* ScreenLocker::GetViewByID(int id) {
+  return lock_widget_->GetRootView()->GetViewByID(id);
+}
+
 // static
 void ScreenLocker::Show() {
   VLOG(1) << "In ScreenLocker::Show";
   UserMetrics::RecordAction(UserMetricsAction("ScreenLocker_Show"));
   DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
 
   // Exit fullscreen.
   Browser* browser = BrowserList::GetLastActive();
   // browser can be NULL if we receive a lock request before the first browser
   // window is shown.
@@ skipping 180 matching lines @@
 
 bool ScreenLocker::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     StartScreenSaver();
     return true;
   }
   return false;
 }
 
 }  // namespace chromeos