Rebase the MessageBubble on the new views bubble.

chrome/browser/chromeos/login/screen_locker_views.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_views.h"
 
 #include <X11/extensions/XTest.h>
 #include <X11/keysym.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
@@ skipping 13 matching lines @@
 #include "chrome/browser/chromeos/status/status_area_view_chromeos.h"
 #include "chrome/browser/chromeos/view_ids.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/user_metrics.h"
 #include "grit/theme_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/screen.h"
+#include "views/controls/textfield/textfield.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include "chrome/browser/chromeos/legacy_window_manager/wm_ipc.h"
+#include "views/widget/native_widget_gtk.h"
 #endif
 
 namespace {
 
 // The active ScreenLockerDelegate.
 chromeos::ScreenLockerViews* screen_locker_view_ = NULL;
 
 // The maximum duration for which locker should try to grab the keyboard and
 // mouse and its interval for regrabbing on failure.
 const int kMaxGrabFailureSec = 30;
 const int64 kRetryGrabIntervalMs = 500;
 
 // Maximum number of times we'll try to grab the keyboard and mouse before
 // giving up.  If we hit the limit, Chrome exits and the session is terminated.
 const int kMaxGrabFailures = kMaxGrabFailureSec * 1000 / kRetryGrabIntervalMs;
 
 // A idle time to show the screen saver in seconds.
 const int kScreenSaverIdleTimeout = 15;
 
 // A ScreenLock window that covers entire screen to keep the keyboard
 // focus/events inside the grab widget.
 class LockWindow : public views::NativeWidgetGtk {
  public:
   LockWindow()
       : views::NativeWidgetGtk(new views::Widget),
         toplevel_focus_widget_(NULL) {
     EnableDoubleBuffer(true);
+    g_signal_connect(GetNativeView(), "client-event",
+                     G_CALLBACK(OnClientEventThunk), this);
   }
 
   // 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;
   }
 
   virtual gboolean OnButtonPress(GtkWidget* widget,
                                  GdkEventButton* event) OVERRIDE {
     // Don't handle mouse event in the lock wnidow and
     // nor propagate to child.
     return true;
   }
 
   virtual void OnDestroy(GtkWidget* object) OVERRIDE {
     VLOG(1) << "OnDestroy: LockWindow destroyed";
     views::NativeWidgetGtk::OnDestroy(object);
   }
 
   virtual void ClearNativeFocus() OVERRIDE {
     DCHECK(toplevel_focus_widget_);
     gtk_widget_grab_focus(toplevel_focus_widget_);
   }
 
+  // Event handler for client-event.
+  CHROMEGTK_CALLBACK_1(LockWindow, void, OnClientEvent, GdkEventClient*);
+
   // 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_can_focus(widget, TRUE);
     toplevel_focus_widget_ = widget;
   }
 
  private:
   // The widget we set focus to when clearning the focus on native
   // widget.  In screen locker, gdk input is grabbed in GrabWidget,
   // and resetting the focus by using gtk_window_set_focus seems to
   // confuse gtk and doesn't let focus move to native widget under
   // GrabWidget.
   GtkWidget* toplevel_focus_widget_;
 
   DISALLOW_COPY_AND_ASSIGN(LockWindow);
 };
 
+void LockWindow::OnClientEvent(GtkWidget* widget, GdkEventClient* event) {
+#if defined(TOOLKIT_USES_GTK)
+  chromeos::WmIpc::Message msg;
+  chromeos::WmIpc::instance()->DecodeMessage(*event, &msg);
+  if (msg.type() ==
+      chromeos::WM_IPC_MESSAGE_CHROME_NOTIFY_SCREEN_REDRAWN_FOR_LOCK) {
+    screen_locker_view_->OnWindowManagerReady();
+  }
+#endif
+}
+
 // GrabWidget's root view to layout the ScreenLockView at the center
 // and the Shutdown button at the left top.
 class GrabWidgetRootView
     : public views::View,
       public chromeos::ScreenLockerViews::ScreenLockViewContainer {
  public:
   explicit GrabWidgetRootView(chromeos::ScreenLockView* screen_lock_view)
       : screen_lock_view_(screen_lock_view),
         shutdown_button_(new chromeos::ShutdownButton()) {
     shutdown_button_->Init();
@@ skipping 491 matching lines @@
   LockWindow* lock_window = new LockWindow();
   lock_window_ = lock_window->GetWidget();
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   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(screen_locker_);
     screen_lock_view_->Init();
     screen_lock_view_->SetEnabled(false);
     screen_lock_view_->StartThrobber();
   } else {
     input_event_observer_.reset(new InputEventObserver(screen_locker_));
     MessageLoopForUI::current()->AddObserver(input_event_observer_.get());
   }
@@ skipping 167 matching lines @@
   ignore_result(secondary_view_.release());
   screen_lock_view_->SetVisible(false);
   grab_container_->SetScreenLockView(captcha_view_);
   background_container_->SetScreenLockView(captcha_view_);
   captcha_view_->SetVisible(true);
   // Take ScreenLockView ownership now that it's removed from grab_container_.
   secondary_view_.reset(screen_lock_view_);
 }
 
 void ScreenLockerViews::ClearErrors() {
-  if (error_info_) {
-    error_info_->Close();
-    error_info_ = NULL;
-  }
+  if (error_info_)
+    error_info_->GetWidget()->Close();
 }
 
-void ScreenLockerViews::BubbleClosing(Bubble* bubble, bool closed_by_escape) {
+void ScreenLockerViews::OnWidgetClosing(views::Widget* widget) {
+  if (!error_info_ || error_info_->GetWidget() != widget)
+    return;
+
   error_info_ = NULL;
   SetSignoutEnabled(true);
   if (mouse_event_relay_.get()) {
     MessageLoopForUI::current()->RemoveObserver(mouse_event_relay_.get());
     mouse_event_relay_.reset();
   }
 }
 
-bool ScreenLockerViews::CloseOnEscape() {
-  return true;
-}
-
-bool ScreenLockerViews::FadeInOnShow() {
-  return false;
-}
-
-void ScreenLockerViews::OnLinkActivated(size_t index) {
-}
-
 void ScreenLockerViews::OnCaptchaEntered(const std::string& captcha) {
   // Captcha dialog is only shown when LoginPerformer instance exists,
   // i.e. blocking UI after password change is in place.
   DCHECK(LoginPerformer::default_performer());
   LoginPerformer::default_performer()->set_captcha(captcha);
 
   // ScreenLockView ownership is passed to grab_container_.
   // Need to save return value here so that compile
   // doesn't fail with "unused result" warning.
   ignore_result(secondary_view_.release());
   captcha_view_->SetVisible(false);
   grab_container_->SetScreenLockView(screen_lock_view_);
   background_container_->SetScreenLockView(screen_lock_view_);
   screen_lock_view_->SetVisible(true);
   screen_lock_view_->ClearAndSetFocusToPassword();
 
   // Take CaptchaView ownership now that it's removed from grab_container_.
   secondary_view_.reset(captcha_view_);
   ShowErrorMessage(postponed_error_message_, false);
   postponed_error_message_.clear();
 }
 
+void ScreenLockerViews::OnWindowManagerReady() {
+  DVLOG(1) << "OnClientEvent: drawn for lock";
+  drawn_ = true;
+  if (input_grabbed_)
+    ScreenLockReady();
+}
+
 ScreenLockerViews::~ScreenLockerViews() {
   if (input_event_observer_.get())
     MessageLoopForUI::current()->RemoveObserver(input_event_observer_.get());
   if (locker_input_event_observer_.get()) {
     lock_widget_->GetFocusManager()->UnregisterAccelerator(
         ui::Accelerator(ui::VKEY_ESCAPE, false, false, false), this);
     MessageLoopForUI::current()->RemoveObserver(
         locker_input_event_observer_.get());
   }
 
   gdk_keyboard_ungrab(GDK_CURRENT_TIME);
   gdk_pointer_ungrab(GDK_CURRENT_TIME);
 
   DCHECK(lock_window_);
   VLOG(1) << "~ScreenLocker(): Closing ScreenLocker window.";
   lock_window_->Close();
   // lock_widget_ will be deleted by gtk's destroy signal.
   screen_locker_view_ = NULL;
 }
 
-void ScreenLockerViews::OnWindowManagerReady() {
-  DVLOG(1) << "OnClientEvent: drawn for lock";
-  drawn_ = true;
-  if (input_grabbed_)
-    ScreenLockReady();
-}
-
 void ScreenLockerViews::ShowErrorBubble(
     const string16& message,
     views::BubbleBorder::ArrowLocation arrow_location) {
-  if (error_info_)
-    error_info_->Close();
+  ClearErrors();
 
-  gfx::Rect rect = screen_lock_view_->GetPasswordBoundsRelativeTo(
-      lock_widget_->GetRootView());
-  gfx::Rect lock_widget_bounds = lock_widget_->GetClientAreaScreenBounds();
-  rect.Offset(lock_widget_bounds.x(), lock_widget_bounds.y());
-  error_info_ = MessageBubble::ShowNoGrab(
-      lock_window_,
-      rect,
+  // TODO(nkostylev): Add help link.
+  error_info_ = new MessageBubble(
+      screen_lock_view_->password_field(),
       arrow_location,
       ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING),
-      UTF16ToWide(message),
-      UTF16ToWide(string16()),  // TODO(nkostylev): Add help link.
-      this);
+      message,
+      string16());
+  MessageBubble::ShowBubble(error_info_);
+  error_info_->GetWidget()->AddObserver(this);
 
 #if !defined(TOUCH_UI)
   if (mouse_event_relay_.get())
     MessageLoopForUI::current()->RemoveObserver(mouse_event_relay_.get());
   mouse_event_relay_.reset(
       new MouseEventRelay(lock_widget_->GetNativeView()->window,
-                          error_info_->GetNativeView()->window));
+                          error_info_->GetWidget()->GetNativeView()->window));
   MessageLoopForUI::current()->AddObserver(mouse_event_relay_.get());
 #endif
 }
 
 bool ScreenLockerViews::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     screen_locker_view_->StartScreenSaver();
     return true;
   }
   return false;
 }
 
-void ScreenLockerViews::OnClientEvent(GtkWidget* widge, GdkEventClient* event) {
-#if defined(TOOLKIT_USES_GTK)
-  WmIpc::Message msg;
-  WmIpc::instance()->DecodeMessage(*event, &msg);
-  if (msg.type() == WM_IPC_MESSAGE_CHROME_NOTIFY_SCREEN_REDRAWN_FOR_LOCK) {
-    OnWindowManagerReady();
-  }
-#endif
-}
-
 }  // namespace chromeos