Rework the way Widget::Init works:

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()
-      : views::WidgetGtk(views::WidgetGtk::TYPE_WINDOW),
-        toplevel_focus_widget_(NULL) {
+  LockWindow() : 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 63 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)
-      : views::WidgetGtk(views::WidgetGtk::TYPE_CHILD),
-        screen_locker_(screen_locker),
+      : 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 172 matching lines @@
     XFlush(display);
   }
 }
 
 // BackgroundView for ScreenLocker, which layouts a lock widget in
 // addition to other background components.
 class ScreenLockerBackgroundView
     : public chromeos::BackgroundView,
       public chromeos::ScreenLocker::ScreenLockViewContainer {
  public:
-  ScreenLockerBackgroundView(views::WidgetGtk* lock_widget,
+  ScreenLockerBackgroundView(views::Widget* lock_widget,
                              views::View* screen_lock_view)
       : lock_widget_(lock_widget),
         screen_lock_view_(screen_lock_view) {
   }
 
   virtual ScreenMode GetScreenMode() const OVERRIDE {
     return kScreenLockerMode;
   }
 
   virtual void Layout() OVERRIDE {
@@ skipping 12 matching lines @@
     }
   }
 
   // ScreenLocker::ScreenLockViewContainer implementation:
   virtual void SetScreenLockView(views::View* screen_lock_view) OVERRIDE {
     screen_lock_view_ =  screen_lock_view;
     Layout();
   }
 
  private:
-  views::WidgetGtk* lock_widget_;
+  views::Widget* lock_widget_;
 
   views::View* screen_lock_view_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockerBackgroundView);
 };
 
 }  // namespace
 
 namespace chromeos {
 
@@ skipping 156 matching lines @@
 }
 
 void ScreenLocker::Init() {
   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_->Init(NULL, init_bounds);
+  views::Widget::CreateParams params(views::Widget::CreateParams::TYPE_WINDOW);
+  params.bounds = init_bounds;
+  lock_window_->Init(params);
 
   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;
-  lock_widget_->MakeTransparent();
-  lock_widget_->InitWithWidget(lock_window_, gfx::Rect());
+  views::Widget::CreateParams lock_params(
+      views::Widget::CreateParams::TYPE_CONTROL);
+  lock_params.transparent = true;
+  lock_params.parent_widget = lock_window_;
+  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(
@@ skipping 30 matching lines @@
   gtk_window_group_add_window(window_group,
                               GTK_WINDOW(lock_window_->GetNativeView()));
   g_object_unref(window_group);
 
   // Don't let X draw default background, which was causing flash on
   // resume.
   gdk_window_set_back_pixmap(lock_window_->GetNativeView()->window,
                              NULL, false);
   gdk_window_set_back_pixmap(lock_widget_->GetNativeView()->window,
                              NULL, false);
-  lock_window->set_toplevel_focus_widget(lock_widget_->window_contents());
+  lock_window->set_toplevel_focus_widget(
+      static_cast<views::WidgetGtk*>(lock_widget_->native_widget())->
+          window_contents());
 
   // Create the SystemKeyEventListener so it can listen for system keyboard
   // messages regardless of focus while screen locked.
   SystemKeyEventListener::GetInstance();
 }
 
 void ScreenLocker::OnLoginFailure(const LoginFailure& error) {
   DVLOG(1) << "OnLoginFailure";
   UserMetrics::RecordAction(UserMetricsAction("ScreenLocker_OnLoginFailure"));
   if (authentication_start_time_.is_null()) {
@@ skipping 369 matching lines @@
 
 bool ScreenLocker::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     StartScreenSaver();
     return true;
   }
   return false;
 }
 
 }  // namespace chromeos