Re-land:

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 180 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ScreenLockObserver);
 };
 
 static base::LazyInstance<ScreenLockObserver> g_screen_lock_observer(
     base::LINKER_INITIALIZED);
 
 // A ScreenLock window that covers entire screen to keep the keyboard
 // focus/events inside the grab widget.
 class LockWindow : public views::WidgetGtk {
  public:
-  LockWindow() : toplevel_focus_widget_(NULL) {
+  LockWindow()
+      : views::WidgetGtk(new views::Widget),
+        toplevel_focus_widget_(NULL) {
     EnableDoubleBuffer(true);
   }
 
   // GTK propagates key events from parents to children.
   // Make sure LockWindow will never handle key events.
   virtual gboolean OnEventKey(GtkWidget* widget, GdkEventKey* event) OVERRIDE {
     // Don't handle key event in the lock window.
     return false;
   }
 
@@ skipping 70 matching lines @@
 
   chromeos::ShutdownButton* shutdown_button_;
 
   DISALLOW_COPY_AND_ASSIGN(GrabWidgetRootView);
 };
 
 // A child widget that grabs both keyboard and pointer input.
 class GrabWidget : public views::WidgetGtk {
  public:
   explicit GrabWidget(chromeos::ScreenLocker* screen_locker)
-      : screen_locker_(screen_locker),
+      : views::WidgetGtk(new views::Widget),
+        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() OVERRIDE {
     views::WidgetGtk::Show();
@@ skipping 420 matching lines @@
 
 void ScreenLocker::Init() {
   static const GdkColor kGdkBlack = {0, 0, 0, 0};
 
   authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
 
   gfx::Point left_top(1, 1);
   gfx::Rect init_bounds(views::Screen::GetMonitorAreaNearestPoint(left_top));
 
   LockWindow* lock_window = new LockWindow();
-  lock_window_ = lock_window;
+  lock_window_ = lock_window->GetWidget();
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.bounds = init_bounds;
+  params.native_widget = lock_window;
   lock_window_->Init(params);
   gtk_widget_modify_bg(
       lock_window_->GetNativeView(), GTK_STATE_NORMAL, &kGdkBlack);
 
   g_signal_connect(lock_window_->GetNativeView(), "client-event",
                    G_CALLBACK(OnClientEventThunk), this);
 
   // GTK does not like zero width/height.
   if (!unlock_on_input_) {
     screen_lock_view_ = new ScreenLockView(this);
     screen_lock_view_->Init();
     screen_lock_view_->SetEnabled(false);
     screen_lock_view_->StartThrobber();
   } else {
     input_event_observer_.reset(new InputEventObserver(this));
     MessageLoopForUI::current()->AddObserver(input_event_observer_.get());
   }
 
   // Hang on to a cast version of the grab widget so we can call its
   // TryGrabAllInputs() method later.  (Nobody else needs to use it, so moving
   // its declaration to the header instead of keeping it in an anonymous
   // namespace feels a bit ugly.)
-  GrabWidget* cast_lock_widget = new GrabWidget(this);
-  lock_widget_ = cast_lock_widget;
+  GrabWidget* grab_widget = new GrabWidget(this);
+  lock_widget_ = grab_widget->GetWidget();
   views::Widget::InitParams lock_params(
       views::Widget::InitParams::TYPE_CONTROL);
   lock_params.transparent = true;
   lock_params.parent_widget = lock_window_;
+  lock_params.native_widget = grab_widget;
   lock_widget_->Init(lock_params);
   if (screen_lock_view_) {
     GrabWidgetRootView* root_view = new GrabWidgetRootView(screen_lock_view_);
     grab_container_ = root_view;
     lock_widget_->SetContentsView(root_view);
   }
   lock_widget_->Show();
 
   // Configuring the background url.
   std::string url_string =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kScreenSaverUrl);
   ScreenLockerBackgroundView* screen_lock_background_view_ =
       new ScreenLockerBackgroundView(lock_widget_, screen_lock_view_);
   background_container_ = screen_lock_background_view_;
   background_view_ = screen_lock_background_view_;
   background_view_->Init(GURL(url_string));
   if (background_view_->ScreenSaverEnabled())
     StartScreenSaver();
 
   DCHECK(GTK_WIDGET_REALIZED(lock_window_->GetNativeView()));
   WmIpc::instance()->SetWindowType(
       lock_window_->GetNativeView(),
       WM_IPC_WINDOW_CHROME_SCREEN_LOCKER,
       NULL);
 
   lock_window_->SetContentsView(background_view_);
   lock_window_->Show();
 
-  cast_lock_widget->ClearGtkGrab();
+  grab_widget->ClearGtkGrab();
 
   // Call this after lock_window_->Show(); otherwise the 1st invocation
   // of gdk_xxx_grab() will always fail.
-  cast_lock_widget->TryGrabAllInputs();
+  grab_widget->TryGrabAllInputs();
 
   // Add the window to its own group so that its grab won't be stolen if
   // gtk_grab_add() gets called on behalf on a non-screen-locker widget (e.g.
   // a modal dialog) -- see http://crosbug.com/8999.  We intentionally do this
   // after calling ClearGtkGrab(), as want to be in the default window group
   // then so we can break any existing GTK grabs.
   GtkWindowGroup* window_group = gtk_window_group_new();
   gtk_window_group_add_window(window_group,
                               GTK_WINDOW(lock_window_->GetNativeView()));
   g_object_unref(window_group);
@@ skipping 383 matching lines @@
 
 bool ScreenLocker::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     StartScreenSaver();
     return true;
   }
   return false;
 }
 
 }  // namespace chromeos