Place the spinner in the right corner of the controls window.

chrome/browser/chromeos/login/user_controller.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/user_controller.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "app/l10n_util.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "cros/chromeos_wm_ipc_enums.h"
 #include "gfx/canvas.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/background.h"
 #include "views/controls/button/native_button.h"
 #include "views/controls/label.h"
+#include "views/controls/throbber.h"
 #include "views/grid_layout.h"
 #include "views/painter.h"
 #include "views/screen.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_gtk.h"
 
 using views::ColumnSet;
 using views::GridLayout;
 using views::WidgetGtk;
 
@@ skipping 21 matching lines @@
  public:
   ClickNotifyingWidget(views::WidgetGtk::Type type,
                        UserController* controller)
       : WidgetGtk(type),
         controller_(controller) {
   }
 
  private:
   gboolean OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
     if (!controller_->is_user_selected())
-      controller_->SelectUser(controller_->user_index());
+      controller_->SelectUserRelative(0);
 
     return views::WidgetGtk::OnButtonPress(widget, event);
   }
 
   UserController* controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ClickNotifyingWidget);
 };
 
 void CloseWindow(views::WidgetGtk* window) {
@@ skipping 24 matching lines @@
       is_guest_(is_guest),
       is_owner_(false),
       show_name_tooltip_(false),
       delegate_(delegate),
       controls_window_(NULL),
       image_window_(NULL),
       border_window_(NULL),
       label_window_(NULL),
       unselected_label_window_(NULL),
       user_view_(NULL),
-      new_user_view_(NULL),
-      existing_user_view_(NULL),
-      guest_user_view_(NULL),
       label_view_(NULL),
       unselected_label_view_(NULL),
+      user_input_(NULL),
+      throbber_host_(NULL),
       method_factory_(this) {
   registrar_.Add(
       this,
       NotificationType::LOGIN_USER_IMAGE_CHANGED,
       NotificationService::AllSources());
 }
 
 UserController::UserController(Delegate* delegate,
                                const UserManager::User& user)
     : user_index_(-1),
       is_user_selected_(false),
       is_new_user_(false),
       is_guest_(false),
       // Empty 'cached_owner()' means that owner hasn't been cached yet, not
       // that owner has an empty email.
       is_owner_(user.email() == UserCrosSettingsProvider::cached_owner()),
       show_name_tooltip_(false),
       user_(user),
       delegate_(delegate),
       controls_window_(NULL),
       image_window_(NULL),
       border_window_(NULL),
       label_window_(NULL),
       unselected_label_window_(NULL),
       user_view_(NULL),
-      new_user_view_(NULL),
-      existing_user_view_(NULL),
-      guest_user_view_(NULL),
       label_view_(NULL),
       unselected_label_view_(NULL),
+      user_input_(NULL),
+      throbber_host_(NULL),
       method_factory_(this) {
   DCHECK(!user.email().empty());
   registrar_.Add(
       this,
       NotificationType::LOGIN_USER_IMAGE_CHANGED,
       NotificationService::AllSources());
 }
 
 UserController::~UserController() {
   // Reset the widget delegate of every window to NULL, so the user
@@ skipping 14 matching lines @@
   controls_window_ =
       CreateControlsWindow(index, &controls_width, &controls_height,
                            need_browse_without_signin);
   image_window_ = CreateImageWindow(index);
   CreateBorderWindow(index, total_user_count, controls_width, controls_height);
   label_window_ = CreateLabelWindow(index, WM_IPC_WINDOW_LOGIN_LABEL);
   unselected_label_window_ =
       CreateLabelWindow(index, WM_IPC_WINDOW_LOGIN_UNSELECTED_LABEL);
 }
 
-void UserController::SetPasswordEnabled(bool enable) {
-  DCHECK(!is_new_user_);
-  existing_user_view_->password_field()->SetEnabled(enable);
-  if (enable) {
-    user_view_->StopThrobber();
-    delegate_->SetStatusAreaEnabled(enable);
-  } else {
-    delegate_->SetStatusAreaEnabled(enable);
-    user_view_->StartThrobber();
-  }
+void UserController::StartThrobber() {
+  throbber_host_->StartThrobber();
+}
+
+void UserController::StopThrobber() {
+  throbber_host_->StopThrobber();
 }
 
 std::wstring UserController::GetNameTooltip() const {
   if (is_new_user_)
     return l10n_util::GetString(IDS_ADD_USER);
   if (is_guest_)
     return l10n_util::GetString(IDS_GO_INCOGNITO_BUTTON);
 
   // Tooltip contains user's display name and his email domain to distinguish
   // this user from the other one with the same display name.
   const std::string& email = user_.email();
   size_t at_pos = email.rfind('@');
   if (at_pos == std::string::npos) {
     NOTREACHED();
     return std::wstring();
   }
   size_t domain_start = at_pos + 1;
   std::string domain = email.substr(domain_start,
                                     email.length() - domain_start);
   return UTF8ToWide(base::StringPrintf("%s (%s)",
                                        user_.GetDisplayName().c_str(),
                                        domain.c_str()));
 }
 
-void UserController::ClearAndEnablePassword() {
-  if (is_new_user_) {
-    // TODO(avayvod): This code seems not reachable to me.
-    new_user_view_->ClearAndEnablePassword();
-  } else {
-    existing_user_view_->password_field()->SetText(string16());
-    SetPasswordEnabled(true);
-    FocusPasswordField();
-  }
+void UserController::ClearAndEnableFields() {
+  user_input_->ClearAndFocusControls();
+  user_input_->EnableInputControls(true);
+  SetStatusAreaEnabled(true);
+  StopThrobber();
 }
 
-void UserController::ClearAndEnableFields() {
-  if (is_new_user_) {
-    new_user_view_->ClearAndEnableFields();
-  } else if (is_guest_) {
-    guest_user_view_->FocusSignInButton();
-  } else {
-    ClearAndEnablePassword();
-  }
+void UserController::ClearAndEnablePassword() {
+  user_input_->ClearAndFocusPassword();
+  user_input_->EnableInputControls(true);
+  SetStatusAreaEnabled(true);
+  StopThrobber();
+}
+
+gfx::Rect UserController::GetMainInputScreenBounds() const {
+  return user_input_->GetMainInputScreenBounds();
 }
 
 void UserController::EnableNameTooltip(bool enable) {
   std::wstring tooltip_text;
   if (enable)
     tooltip_text = GetNameTooltip();
 
   if (user_view_)
     user_view_->SetTooltipText(tooltip_text);
   if (label_view_)
     label_view_->SetTooltipText(tooltip_text);
   if (unselected_label_view_)
     unselected_label_view_->SetTooltipText(tooltip_text);
 }
 
-void UserController::ButtonPressed(views::Button* sender,
-                                   const views::Event& event) {
-  Login();
-}
-
-bool UserController::HandleKeystroke(
-    views::Textfield* sender,
-    const views::Textfield::Keystroke& keystroke) {
-  if (keystroke.GetKeyboardCode() == app::VKEY_RETURN) {
-    Login();
-    return true;
-  } else if (keystroke.GetKeyboardCode() == app::VKEY_LEFT) {
-    SelectUser(user_index() - 1);
-    return true;
-  } else if (keystroke.GetKeyboardCode() == app::VKEY_RIGHT) {
-    SelectUser(user_index() + 1);
-    return true;
-  }
-  delegate_->ClearErrors();
-  return false;
-}
-
-void UserController::ContentsChanged(views::Textfield* sender,
-                                     const string16& new_contents) {
-}
-
 void UserController::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (type != NotificationType::LOGIN_USER_IMAGE_CHANGED ||
       !user_view_)
     return;
 
   UserManager::User* user = Details<UserManager::User>(details).ptr();
   if (user_.email() != user->email())
     return;
 
   user_.set_image(user->image());
   user_view_->SetImage(user_.image(), user_.image());
 }
 
-void UserController::Login() {
-  if (is_guest_) {
-    delegate_->LoginOffTheRecord();
-  } else {
-    // Delegate will reenable as necessary.
-    SetPasswordEnabled(false);
-
-    delegate_->Login(this, existing_user_view_->password_field()->text());
-  }
-}
-
 void UserController::IsActiveChanged(bool active) {
   is_user_selected_ = active;
   if (active) {
     delegate_->OnUserSelected(this);
     user_view_->SetRemoveButtonVisible(
         !is_new_user_ && !is_guest_ && !is_owner_);
   } else {
     user_view_->SetRemoveButtonVisible(false);
     delegate_->ClearErrors();
   }
@@ skipping 21 matching lines @@
 
   window->Show();
 }
 
 WidgetGtk* UserController::CreateControlsWindow(
     int index,
     int* width, int* height,
     bool need_browse_without_signin) {
   views::View* control_view;
   if (is_new_user_) {
-    new_user_view_ =
+    NewUserView* new_user_view =
         new NewUserView(this, true, need_browse_without_signin);
-    new_user_view_->Init();
-    control_view = new_user_view_;
+    new_user_view->Init();
+    control_view = new_user_view;
+    user_input_ = new_user_view;
+    throbber_host_ = new_user_view;
   } else if (is_guest_) {
-    guest_user_view_ = new GuestUserView(this);
-    guest_user_view_->RecreateFields();
-    control_view = guest_user_view_;
+    GuestUserView* guest_user_view = new GuestUserView(this);
+    guest_user_view->RecreateFields();
+    control_view = guest_user_view;
+    user_input_ = guest_user_view;
+    throbber_host_ = guest_user_view;
   } else {
-    existing_user_view_ = new ExistingUserView(this);
-    existing_user_view_->RecreateFields();
-    control_view = existing_user_view_;
+    ExistingUserView* existing_user_view = new ExistingUserView(this);
+    existing_user_view->RecreateFields();
+    control_view = existing_user_view;
+    user_input_ = existing_user_view;
+    throbber_host_ = existing_user_view;
   }
 
   *height = kControlsHeight;
   *width = kUserImageSize;
   if (is_new_user_) {
-    DCHECK(new_user_view_);
-    gfx::Size size = new_user_view_->GetPreferredSize();
+    gfx::Size size = control_view->GetPreferredSize();
     *width = size.width();
     *height = size.height();
   }
 
   WidgetGtk* window = new WidgetGtk(WidgetGtk::TYPE_WINDOW);
   ConfigureLoginWindow(window,
                        index,
                        gfx::Rect(*width, *height),
                        WM_IPC_WINDOW_LOGIN_CONTROLS,
                        control_view);
@@ skipping 118 matching lines @@
       login::kSelectedLabelHeight : login::kUnselectedLabelHeight;
   WidgetGtk* window = new ClickNotifyingWidget(WidgetGtk::TYPE_WINDOW, this);
   ConfigureLoginWindow(window,
                        index,
                        gfx::Rect(0, 0, width, height),
                        type,
                        label);
   return window;
 }
 
-gfx::Rect UserController::GetScreenBounds() const {
-  if (is_new_user_)
-    return new_user_view_->GetUsernameBounds();
-  else
-    return existing_user_view_->password_field()->GetScreenBounds();
-}
-
 void UserController::OnLogin(const std::string& username,
                              const std::string& password) {
-  user_.set_email(username);
+  if (is_new_user_)
+    user_.set_email(username);
+
+  user_input_->EnableInputControls(false);
+  SetStatusAreaEnabled(false);
+  StartThrobber();
+
   delegate_->Login(this, UTF8ToUTF16(password));
 }
 
 void UserController::OnCreateAccount() {
   delegate_->ActivateWizard(WizardController::kAccountScreenName);
 }
 
 void UserController::OnLoginOffTheRecord() {
+  user_input_->EnableInputControls(false);
+  SetStatusAreaEnabled(false);
+  StartThrobber();
+
   delegate_->LoginOffTheRecord();
 }
 
 void UserController::ClearErrors() {
   delegate_->ClearErrors();
 }
 
 void UserController::NavigateAway() {
-  SelectUser(user_index() - 1);
+  SelectUserRelative(-1);
 }
 
 void UserController::OnRemoveUser() {
   // Must not proceed without signature verification.
   UserCrosSettingsProvider user_settings;
   bool trusted_owner_available = user_settings.RequestTrustedOwner(
       method_factory_.NewRunnableMethod(&UserController::OnRemoveUser));
   if (!trusted_owner_available) {
     // Value of owner email is still not verified.
     // Another attempt will be invoked after verification completion.
     return;
   }
   if (user().email() == UserCrosSettingsProvider::cached_owner()) {
     // Owner is not allowed to be removed from the device.
     return;
   }
   delegate_->RemoveUser(this);
 }
 
-void UserController::SelectUser(int index) {
-  delegate_->SelectUser(index);
-}
-
-void UserController::FocusPasswordField() {
-  existing_user_view_->FocusPasswordField();
+void UserController::SelectUserRelative(int shift) {
+  delegate_->SelectUser(user_index() + shift);
 }
 
 }  // namespace chromeos