Reflow of user menu's active profile card into a button

chrome/browser/ui/views/profiles/profile_chooser_view.cc

 // Copyright 2014 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/ui/views/profiles/profile_chooser_view.h"
 
 #include "base/macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 164 matching lines @@
   back_button->set_request_focus_on_press(true);
   return back_button;
 }
 
 // BackgroundColorHoverButton -------------------------------------------------
 
 // A custom button that allows for setting a background color when hovered over.
 class BackgroundColorHoverButton : public views::LabelButton {
  public:
   BackgroundColorHoverButton(views::ButtonListener* listener,
+                             const base::string16& text)
+      : views::LabelButton(listener, text) {
+    SetImageLabelSpacing(views::kItemLabelSpacing);
+    const int button_margin = switches::IsMaterialDesignUserMenu()
+                                  ? kMaterialMenuEdgeMargin
+                                  : views::kButtonHEdgeMarginNew;
+    SetBorder(
+        views::Border::CreateEmptyBorder(0, button_margin, 0, button_margin));
+    SetFocusForPlatform();
+    set_request_focus_on_press(true);
+  }
+
+  BackgroundColorHoverButton(views::ButtonListener* listener,
                              const base::string16& text,
                              const gfx::ImageSkia& icon)
-      : views::LabelButton(listener, text) {
-    SetImageLabelSpacing(views::kItemLabelSpacing);
-    SetBorder(views::Border::CreateEmptyBorder(
-        0, views::kButtonHEdgeMarginNew, 0, views::kButtonHEdgeMarginNew));
-    SetMinSize(gfx::Size(0,
-        kButtonHeight + views::kRelatedControlVerticalSpacing));
+      : BackgroundColorHoverButton(listener, text) {
+    SetMinSize(gfx::Size(
+        icon.width(), kButtonHeight + views::kRelatedControlVerticalSpacing));
     SetImage(STATE_NORMAL, icon);
-    SetFocusForPlatform();
-    set_request_focus_on_press(true);
   }
 
   ~BackgroundColorHoverButton() override {}
 
  private:
   // views::LabelButton:
   void OnPaint(gfx::Canvas* canvas) override {
     if ((state() == STATE_PRESSED) ||
         (state() == STATE_HOVERED)) {
       canvas->DrawColor(GetNativeTheme()->GetSystemColor(
@@ skipping 12 matching lines @@
  public:
   explicit SizedContainer(const gfx::Size& preferred_size)
       : preferred_size_(preferred_size) {}
 
   gfx::Size GetPreferredSize() const override { return preferred_size_; }
 
  private:
   gfx::Size preferred_size_;
 };
 
+// NonInteractiveContainer -------------------------------------------------
+
+// A simple container view that does not process events within subtree.
+class NonInteractiveContainer : public views::View {
+ public:
+  NonInteractiveContainer() {}
+
+  // views::CanProcessEventsWithinSubtree:
+  bool CanProcessEventsWithinSubtree() const override { return false; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NonInteractiveContainer);
+};
+
 // A view to host the GAIA webview overlapped with a back button.  This class
 // is needed to reparent the back button inside a native view so that on
 // windows, user input can be be properly routed to the button.
 class HostView : public views::View {
  public:
   HostView() {}
 
   void Initialize(views::View* title_view, views::View* main_view);
 
  private:
@@ skipping 33 matching lines @@
   gfx::Rect bounds(title_view_->GetPreferredSize());
   title_view_->SetBoundsRect(bounds);
   bounds.Offset(kTitleViewNativeWidgetOffset, kTitleViewNativeWidgetOffset);
   title_widget_->SetBounds(bounds);
 }
 
 }  // namespace
 
 // RightAlignedIconLabelButton -------------------------------------------------
 
-// A custom LabelButton that has a left-aligned text and right aligned icon.
-// For non-material-design user menu, it has centered text instead.
+// A custom LabelButton that has a center-aligned text and right aligned icon.
+// Only used in non-material-design user menu.
 class RightAlignedIconLabelButton : public views::LabelButton {
  public:
   RightAlignedIconLabelButton(views::ButtonListener* listener,
                               const base::string16& text)
       : views::LabelButton(listener, text) {
     SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-    label()->SetHorizontalAlignment(switches::IsMaterialDesignUserMenu()
-                                        ? gfx::ALIGN_LEFT
-                                        : gfx::ALIGN_CENTER);
+    label()->SetHorizontalAlignment(gfx::ALIGN_CENTER);
   }
 
  protected:
   void Layout() override {
     views::LabelButton::Layout();
 
     // Keep the text centered and the icon right-aligned by stretching the label
     // to take up more of the content area and centering its contents.
     gfx::Rect content_bounds = GetContentsBounds();
     gfx::Rect label_bounds = label()->bounds();
@@ skipping 18 matching lines @@
 const size_t kProfileBadgeWhitePadding = 2;
 
 // A custom Image control that shows a "change" button when moused over.
 class EditableProfilePhoto : public views::LabelButton {
  public:
   EditableProfilePhoto(views::ButtonListener* listener,
                        const gfx::Image& icon,
                        bool is_editing_allowed,
                        Profile* profile)
       : views::LabelButton(listener, base::string16()),
+        interactive_(!switches::IsMaterialDesignUserMenu()),
         photo_overlay_(nullptr),
         profile_(profile) {
     gfx::Image image = profiles::GetSizedAvatarIcon(
         icon, true, icon_image_side(), icon_image_side());
     SetImage(views::LabelButton::STATE_NORMAL, *image.ToImageSkia());
     SetBorder(views::Border::NullBorder());
     if (switches::IsMaterialDesignUserMenu()) {
       SetMinSize(gfx::Size(GetPreferredSize().width() + badge_spacing(),
                            GetPreferredSize().height() + badge_spacing() +
                                views::kRelatedControlSmallVerticalSpacing));
     } else {
       SetSize(GetPreferredSize());
     }
 
     // Calculate the circular mask that will be used to display the photo.
     circular_mask_.addCircle(
         SkIntToScalar(icon_image_side() / 2),
         SkIntToScalar(icon_image_side() / 2) + badge_spacing(),
         SkIntToScalar(icon_image_side() / 2));
 
-    if (!is_editing_allowed) {
+    if (switches::IsMaterialDesignUserMenu() || !is_editing_allowed) {
       SetEnabled(false);
       return;
     }
 
     set_notify_enter_exit_on_child(true);
 
     // Photo overlay that appears when hovering over the button.
     photo_overlay_ = new views::ImageView();
 
     const SkColor kBackgroundColor = SkColorSetARGB(65, 255, 255, 255);
     photo_overlay_->set_background(
         views::Background::CreateSolidBackground(kBackgroundColor));
-    photo_overlay_->SetImage(
-        gfx::CreateVectorIcon(gfx::VectorIconId::PHOTO_CAMERA,
-                              switches::IsMaterialDesignUserMenu() ? 22u : 48u,
-                              SkColorSetRGB(0x33, 0x33, 0x33)));
+    photo_overlay_->SetImage(gfx::CreateVectorIcon(
+        gfx::VectorIconId::PHOTO_CAMERA, 48u, SkColorSetRGB(0x33, 0x33, 0x33)));
 
     photo_overlay_->SetSize(gfx::Size(icon_image_side(), icon_image_side()));
     photo_overlay_->SetY(badge_spacing());
     photo_overlay_->SetVisible(false);
     AddChildView(photo_overlay_);
   }
 
   void OnPaint(gfx::Canvas* canvas) override {
     canvas->Save();
     // Display the profile picture as a circle.
@@ skipping 64 matching lines @@
     return switches::IsMaterialDesignUserMenu() ? kMdImageSide
                                                 : kLargeImageSide;
   }
 
   static int badge_spacing() {
     // The space between the right/bottom edge of the profile badge and the
     // right/bottom edge of the profile icon.
     return switches::IsMaterialDesignUserMenu() ? 4 : 0;
   }
 
+  bool CanProcessEventsWithinSubtree() const override { return interactive_; }
+
  private:
   // views::CustomButton:
   void StateChanged() override {
     bool show_overlay =
         (state() == STATE_PRESSED || state() == STATE_HOVERED || HasFocus());
     if (photo_overlay_)
       photo_overlay_->SetVisible(show_overlay);
   }
 
   void OnFocus() override {
     views::LabelButton::OnFocus();
     if (photo_overlay_)
       photo_overlay_->SetVisible(true);
   }
 
   void OnBlur() override {
     views::LabelButton::OnBlur();
     // Don't hide the overlay if it's being shown as a result of a mouseover.
     if (photo_overlay_ && state() != STATE_HOVERED)
       photo_overlay_->SetVisible(false);
   }
 
+  bool interactive_;
   gfx::Path circular_mask_;
 
   // Image that is shown when hovering over the image button. Can be NULL if
   // the photo isn't allowed to be edited (e.g. for guest profiles).
   views::ImageView* photo_overlay_;
 
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(EditableProfilePhoto);
 };
 
 // EditableProfileName -------------------------------------------------
 
 // A custom text control that turns into a textfield for editing when clicked.
+// Only used in non-material-design user menu.
 class EditableProfileName : public views::View,
                             public views::ButtonListener {
  public:
   EditableProfileName(views::TextfieldController* controller,
                       const base::string16& text,
                       bool is_editing_allowed)
       : button_(nullptr), profile_name_textfield_(nullptr) {
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
 
     ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
     const gfx::FontList& medium_font_list =
         rb->GetFontList(ui::ResourceBundle::MediumFont);
     const gfx::Insets textfield_border_insets =
         views::Textfield().border()->GetInsets();
 
     if (!is_editing_allowed) {
       views::Label* name_label = new views::Label(text);
       name_label->SetBorder(
           views::Border::CreateEmptyBorder(textfield_border_insets));
       name_label->SetFontList(medium_font_list);
-      if (switches::IsMaterialDesignUserMenu())
-        name_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
       AddChildView(name_label);
       return;
     }
 
     profile_name_textfield_ = new views::Textfield();
     // Textfield that overlaps the button.
     profile_name_textfield_->set_controller(controller);
     profile_name_textfield_->SetFontList(medium_font_list);
-    profile_name_textfield_->SetHorizontalAlignment(
-        switches::IsMaterialDesignUserMenu() ? gfx::ALIGN_LEFT
-                                             : gfx::ALIGN_CENTER);
+    profile_name_textfield_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
     profile_name_textfield_->SetVisible(false);
     AddChildView(profile_name_textfield_);
 
     button_ = new RightAlignedIconLabelButton(this, text);
     button_->SetFontList(medium_font_list);
     // Show an "edit" pencil icon when hovering over. In the default state,
     // we need to create an empty placeholder of the correct size, so that
     // the text doesn't jump around when the hovered icon appears.
     // TODO(estade): revisit colors and press effect.
     const int kIconSize = 16;
     button_->SetImage(views::LabelButton::STATE_NORMAL,
                       CreateSquarePlaceholderImage(kIconSize));
     button_->SetImage(views::LabelButton::STATE_HOVERED,
                       gfx::CreateVectorIcon(
                           gfx::VectorIconId::MODE_EDIT, kIconSize,
                           SkColorSetRGB(0x33, 0x33, 0x33)));
     button_->SetImage(views::LabelButton::STATE_PRESSED,
                       gfx::CreateVectorIcon(
                           gfx::VectorIconId::MODE_EDIT, kIconSize,
                           SkColorSetRGB(0x20, 0x20, 0x20)));
     // We need to add a left padding as well as a small top/bottom padding
     // to the text to account for the textfield's border.
-    if (switches::IsMaterialDesignUserMenu()) {
-      button_->SetBorder(views::Border::CreateEmptyBorder(
-          textfield_border_insets +
-          gfx::Insets(0, profile_name_textfield_->GetInsets().left(), 0, 0)));
-    } else {
-      const int kIconTextLabelButtonSpacing = 5;
-      button_->SetBorder(views::Border::CreateEmptyBorder(
-          textfield_border_insets +
-          gfx::Insets(0, kIconSize + kIconTextLabelButtonSpacing, 0, 0)));
-    }
+    const int kIconTextLabelButtonSpacing = 5;
+    button_->SetBorder(views::Border::CreateEmptyBorder(
+        textfield_border_insets +
+        gfx::Insets(0, kIconSize + kIconTextLabelButtonSpacing, 0, 0)));
     AddChildView(button_);
   }
 
   views::Textfield* profile_name_textfield() {
     return profile_name_textfield_;
   }
 
   // Hide the editable textfield to show the profile name button instead.
   void ShowReadOnlyView() {
     button_->SetVisible(true);
@@ skipping 186 matching lines @@
 
 void ProfileChooserView::ResetView() {
   open_other_profile_indexes_map_.clear();
   delete_account_button_map_.clear();
   reauth_account_button_map_.clear();
   manage_accounts_link_ = nullptr;
   signin_current_profile_button_ = nullptr;
   auth_error_email_button_ = nullptr;
   current_profile_photo_ = nullptr;
   current_profile_name_ = nullptr;
+  current_profile_card_ = nullptr;
   guest_profile_button_ = nullptr;
   users_button_ = nullptr;
   go_incognito_button_ = nullptr;
   lock_button_ = nullptr;
   close_all_windows_button_ = nullptr;
   add_account_link_ = nullptr;
   gaia_signin_cancel_button_ = nullptr;
   remove_account_button_ = nullptr;
   account_removal_cancel_button_ = nullptr;
   add_person_button_ = nullptr;
@@ skipping 246 matching lines @@
     bool account_management_available =
         SigninManagerFactory::GetForProfile(browser_->profile())->
             IsAuthenticated() &&
         switches::IsEnableAccountConsistency();
     ShowViewFromMode(account_management_available ?
         profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT :
         profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER);
   } else if (sender == current_profile_photo_) {
     avatar_menu_->EditProfile(avatar_menu_->GetActiveProfileIndex());
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_IMAGE);
+  } else if (sender == current_profile_card_) {
+    avatar_menu_->EditProfile(avatar_menu_->GetActiveProfileIndex());
+    PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_IMAGE);
+    PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_NAME);
+  } else if (sender == manage_accounts_button_) {
+    // This button can either mean show/hide the account management view,
+    // depending on which view it is displayed.
+    ShowViewFromMode(view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT
+                         ? profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER
+                         : profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT);
   } else if (sender == signin_current_profile_button_) {
     ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN);
   } else if (sender == add_person_button_) {
     ProfileMetrics::LogProfileNewAvatarMenuNotYou(
         ProfileMetrics::PROFILE_AVATAR_MENU_NOT_YOU_ADD_PERSON);
     UserManager::Show(base::FilePath(),
                       profiles::USER_MANAGER_NO_TUTORIAL,
                       profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
   } else if (sender == disconnect_button_) {
     ProfileMetrics::LogProfileNewAvatarMenuNotYou(
@@ skipping 479 matching lines @@
   }
 
   return view;
 }
 
 views::View* ProfileChooserView::CreateMaterialDesignCurrentProfileView(
     const AvatarMenu::Item& avatar_item,
     bool is_guest) {
   views::View* view = new views::View();
   view->SetLayoutManager(
-      new views::BoxLayout(views::BoxLayout::kVertical, kMaterialMenuEdgeMargin,
-                           views::kRelatedControlVerticalSpacing,
-                           views::kRelatedControlVerticalSpacing));
+      new views::BoxLayout(views::BoxLayout::kVertical, 0,
+                           views::kRelatedControlVerticalSpacing, 0));
 
-  // Profile container for the profile photo and avatar/user name.
-  views::View* profile_container = new views::View();
+  // Container for the profile photo and avatar/user name.
+  current_profile_card_ =
+      new BackgroundColorHoverButton(this, base::string16());
 
   // Profile picture, left-aligned.
-  current_profile_photo_ = new EditableProfilePhoto(
+  EditableProfilePhoto* current_profile_photo = new EditableProfilePhoto(
       this, avatar_item.icon, !is_guest, browser_->profile());
 
   // Profile name, left-aligned to the right of profile icon.
-  bool editing_allowed =
-      !is_guest && !browser_->profile()->IsLegacySupervised();
-  current_profile_name_ = new EditableProfileName(
-      this, profiles::GetAvatarNameForProfile(browser_->profile()->GetPath()),
-      editing_allowed);
-  views::View* profile_name_container = new views::View();
+  views::Label* current_profile_name = new views::Label(
+      profiles::GetAvatarNameForProfile(browser_->profile()->GetPath()));
+  current_profile_name->SetFontList(
+      ui::ResourceBundle::GetSharedInstance().GetFontListWithDelta(
+          1, gfx::Font::FontStyle::NORMAL, gfx::Font::Weight::MEDIUM));
+  current_profile_name->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  NonInteractiveContainer* profile_name_container =
+      new NonInteractiveContainer();
   int name_container_v_spacing = views::kRelatedControlSmallVerticalSpacing;
-  if (!avatar_item.signed_in)
+  if (!avatar_item.signed_in || switches::IsEnableAccountConsistency())
     name_container_v_spacing += views::kRelatedControlVerticalSpacing;
   profile_name_container->SetLayoutManager(new views::BoxLayout(
       views::BoxLayout::kVertical, 0, name_container_v_spacing, 0));
-  profile_name_container->AddChildView(current_profile_name_);
+  profile_name_container->AddChildView(current_profile_name);
 
   const int between_child_spacing =
       kMaterialMenuEdgeMargin - EditableProfilePhoto::badge_spacing();
-  profile_container->SetLayoutManager(new views::BoxLayout(
+  current_profile_card_->SetLayoutManager(new views::BoxLayout(
       views::BoxLayout::kHorizontal, 0,
       views::kRelatedControlSmallVerticalSpacing, between_child_spacing));
-  profile_container->AddChildView(current_profile_photo_);
-  profile_container->AddChildView(profile_name_container);
-  view->AddChildView(profile_container);
+  current_profile_card_->AddChildView(current_profile_photo);
+  current_profile_card_->AddChildView(profile_name_container);
+  current_profile_card_->SetMinSize(gfx::Size(
+      GetFixedMenuWidth(), current_profile_photo->GetPreferredSize().height() +
+                               2 * views::kRelatedControlSmallVerticalSpacing));
+  view->AddChildView(current_profile_card_);
 
-  if (is_guest)
+  if (is_guest) {
+    current_profile_card_->SetEnabled(false);
     return view;
+  }
 
   // The available links depend on the type of profile that is active.
   if (avatar_item.signed_in) {
     if (switches::IsEnableAccountConsistency()) {
-      base::string16 link_title = l10n_util::GetStringUTF16(
+      base::string16 button_text = l10n_util::GetStringUTF16(
           IsProfileChooser(view_mode_)
               ? IDS_PROFILES_PROFILE_MANAGE_ACCOUNTS_BUTTON
               : IDS_PROFILES_PROFILE_HIDE_MANAGE_ACCOUNTS_BUTTON);
-      manage_accounts_link_ = CreateLink(link_title, this);
-      manage_accounts_link_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-      profile_name_container->AddChildView(manage_accounts_link_);
+      manage_accounts_button_ =
+          new BackgroundColorHoverButton(this, button_text);
+      manage_accounts_button_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+      manage_accounts_button_->SetMinSize(
+          gfx::Size(GetFixedMenuWidth(), kButtonHeight));
+      view->AddChildView(manage_accounts_button_);
     } else {
       views::Label* email_label = new views::Label(avatar_item.username);
       email_label->SetElideBehavior(gfx::ELIDE_EMAIL);
       email_label->SetEnabled(false);
       email_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
       profile_name_container->AddChildView(email_label);
     }
     return view;
   }
 
   SigninManagerBase* signin_manager = SigninManagerFactory::GetForProfile(
       browser_->profile()->GetOriginalProfile());
   if (signin_manager->IsSigninAllowed()) {
+    views::View* extra_links_view = new views::View();
+    views::BoxLayout* extra_links_layout = new views::BoxLayout(
+        views::BoxLayout::kVertical, kMaterialMenuEdgeMargin,
+        views::kRelatedControlVerticalSpacing, kMaterialMenuEdgeMargin);
+    extra_links_layout->set_cross_axis_alignment(
+        views::BoxLayout::CROSS_AXIS_ALIGNMENT_START);
+    extra_links_view->SetLayoutManager(extra_links_layout);
     views::Label* promo =
         new views::Label(l10n_util::GetStringUTF16(IDS_PROFILES_SIGNIN_PROMO));
     promo->SetMultiLine(true);
     promo->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-    view->AddChildView(promo);
+    extra_links_view->AddChildView(promo);
 
     signin_current_profile_button_ =
         views::MdTextButton::CreateSecondaryUiBlueButton(
             this, l10n_util::GetStringFUTF16(
                       IDS_SYNC_START_SYNC_BUTTON_LABEL,
                       l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME)));
-    view->AddChildView(signin_current_profile_button_);
+    extra_links_view->AddChildView(signin_current_profile_button_);
     content::RecordAction(
         base::UserMetricsAction("Signin_Impression_FromAvatarBubbleSignin"));
-    view->SetBorder(views::Border::CreateEmptyBorder(
-        0, 0, views::kRelatedControlVerticalSpacing, 0));
+    extra_links_view->SetBorder(views::Border::CreateEmptyBorder(
+        0, 0, views::kRelatedControlSmallVerticalSpacing, 0));
+    view->AddChildView(extra_links_view);
   }
 
   return view;
 }
 
 views::View* ProfileChooserView::CreateGuestProfileView() {
   gfx::Image guest_icon =
       ui::ResourceBundle::GetSharedInstance().GetImageNamed(
           profiles::GetPlaceholderAvatarIconResourceID());
   AvatarMenu::Item guest_avatar_item(0, base::FilePath(), guest_icon);
@@ skipping 503 matching lines @@
       IncognitoModePrefs::GetAvailability(browser_->profile()->GetPrefs()) !=
           IncognitoModePrefs::DISABLED;
   return incognito_available && !browser_->profile()->IsGuestSession();
 }
 
 void ProfileChooserView::PostActionPerformed(
     ProfileMetrics::ProfileDesktopMenu action_performed) {
   ProfileMetrics::LogProfileDesktopMenu(action_performed, gaia_service_type_);
   gaia_service_type_ = signin::GAIA_SERVICE_TYPE_NONE;
 }