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 73 matching lines @@
 // Helpers --------------------------------------------------------------------
 
 const int kButtonHeight = 32;
 const int kPasswordCombinedFixedGaiaViewWidth = 360;
 const int kFixedGaiaViewWidth = 448;
 const int kFixedAccountRemovalViewWidth = 280;
 const int kFixedSwitchUserViewWidth = 320;
 const int kLargeImageSide = 88;
 const int kMediumImageSide = 40;
 
-const int kTextfieldLabelHorizontalSpacing = 4;
+const int kProfileBarHeight = 56;
 const int kProfileHorizontalSpacing = 16;
 const int kVerticalSpacing = 16;
 
 const int kTitleViewNativeWidgetOffset = 8;
 
 bool IsProfileChooser(profiles::BubbleViewMode mode) {
   return mode == profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER ||
       mode == profiles::BUBBLE_VIEW_MODE_FAST_PROFILE_CHOOSER;
 }
 
@@ skipping 70 matching lines @@
     SetImageLabelSpacing(views::kItemLabelSpacing);
     SetBorder(views::Border::CreateEmptyBorder(
         0, views::kButtonHEdgeMarginNew, 0, views::kButtonHEdgeMarginNew));
     SetMinSize(gfx::Size(0,
         kButtonHeight + views::kRelatedControlVerticalSpacing));
     SetImage(STATE_NORMAL, icon);
     SetFocusForPlatform();
     set_request_focus_on_press(true);
   }
 
+  explicit BackgroundColorHoverButton(views::ButtonListener* listener)
+      : views::LabelButton(listener, base::string16()) {
+    SetMinSize(gfx::Size(0, kProfileBarHeight));
+    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(
           ui::NativeTheme::kColorId_ButtonHoverBackgroundColor));
     }
@@ skipping 109 matching lines @@
 // EditableProfilePhoto -------------------------------------------------
 
 // 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,
                        const gfx::Rect& bounds)
       : views::LabelButton(listener, base::string16()),
+        interactive_(true),
         photo_overlay_(NULL) {
     const int icon_image_side = switches::IsMaterialDesignUserMenu()
         ? kMediumImageSide : kLargeImageSide;
     gfx::Image image = profiles::GetSizedAvatarIcon(
         icon, true, icon_image_side, icon_image_side);
     SetImage(views::LabelButton::STATE_NORMAL, *image.ToImageSkia());
     SetBorder(views::Border::NullBorder());
     SetBoundsRect(bounds);
 
     // Calculate the circular mask that will be used to display the photo.
     circular_mask_.addCircle(SkIntToScalar(bounds.width() / 2),
                              SkIntToScalar(bounds.height() / 2),
                              SkIntToScalar(bounds.width() / 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)));
+        gfx::VectorIconId::PHOTO_CAMERA, 48u, SkColorSetRGB(0x33, 0x33, 0x33)));
 
     photo_overlay_->SetSize(bounds.size());
     photo_overlay_->SetVisible(false);
     AddChildView(photo_overlay_);
   }
 
   void OnPaint(gfx::Canvas* canvas) override {
     // Display the profile picture as a circle.
     canvas->ClipPath(circular_mask_, true);
     views::LabelButton::OnPaint(canvas);
   }
 
   void PaintChildren(const ui::PaintContext& context) override {
     // Display any children (the "change photo" overlay) as a circle.
     ui::ClipRecorder clip_recorder(context);
     clip_recorder.ClipPathWithAntiAliasing(circular_mask_);
     View::PaintChildren(context);
   }
 
+  bool CanProcessEventsWithinSubtree() const override { return interactive_; }
+
+  void set_interactive(bool interactive) { interactive_ = 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_;
 
   DISALLOW_COPY_AND_ASSIGN(EditableProfilePhoto);
 };
 
 // EditableProfileName -------------------------------------------------
 
 // A custom text control that turns into a textfield for editing when clicked.
+// For non-material-design user menu only.
 class EditableProfileName : public views::View,
                             public views::ButtonListener {
  public:
   EditableProfileName(views::TextfieldController* controller,
                       const base::string16& text,
                       bool is_editing_allowed)
       : button_(nullptr), label_(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);
 
     if (!is_editing_allowed) {
       label_ = new views::Label(text);
       label_->SetBorder(views::Border::CreateEmptyBorder(2, 0, 2, 0));
       label_->SetFontList(medium_font_list);
-      if (switches::IsMaterialDesignUserMenu())
-        label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
       AddChildView(label_);
       return;
     }
 
     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(
-          2, kTextfieldLabelHorizontalSpacing, 2, 0));
-    } else {
-      const int kIconTextLabelButtonSpacing = 5;
-      button_->SetBorder(views::Border::CreateEmptyBorder(
-          2, kIconSize + kIconTextLabelButtonSpacing, 2, 0));
-    }
+    const int kIconTextLabelButtonSpacing = 5;
+    button_->SetBorder(views::Border::CreateEmptyBorder(
+        2, kIconSize + kIconTextLabelButtonSpacing, 2, 0));
     AddChildView(button_);
 
     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_);
   }
 
   views::Textfield* profile_name_textfield() {
     return profile_name_textfield_;
   }
 
   // Hide the editable textfield to show the profile name button instead.
   void ShowReadOnlyView() {
@@ skipping 249 matching lines @@
     oauth2_token_service->RemoveObserver(this);
 }
 
 void ProfileChooserView::ResetView() {
   open_other_profile_indexes_map_.clear();
   delete_account_button_map_.clear();
   reauth_account_button_map_.clear();
   manage_accounts_link_ = NULL;
   signin_current_profile_link_ = NULL;
   auth_error_email_button_ = NULL;
+  current_profile_card_ = NULL;
   current_profile_photo_ = NULL;
   current_profile_name_ = NULL;
   users_button_ = NULL;
   go_incognito_button_ = NULL;
   lock_button_ = NULL;
   add_account_link_ = NULL;
   gaia_signin_cancel_button_ = NULL;
   remove_account_button_ = NULL;
   account_removal_cancel_button_ = NULL;
   add_person_button_ = NULL;
@@ skipping 236 matching lines @@
   } else if (sender == gaia_signin_cancel_button_) {
     // The account management view is only available with the
     // --enable-account-consistency flag.
     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_) {
+  } else if (sender == current_profile_photo_ ||
+             sender == current_profile_card_) {
     avatar_menu_->EditProfile(avatar_menu_->GetActiveProfileIndex());
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_IMAGE);
   } else if (sender == signin_current_profile_link_) {
     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);
@@ skipping 486 matching lines @@
     }
   }
 
   return view;
 }
 
 views::View* ProfileChooserView::CreateMaterialDesignCurrentProfileView(
     const AvatarMenu::Item& avatar_item,
     bool is_guest) {
   views::View* view = new views::View();
-  int column_width = GetFixedMenuWidth() - 2 * views::kMaterialHorizontalMargin;
-  views::GridLayout* layout = CreateSingleColumnLayout(view, column_width);
-  layout->SetInsets(views::kRelatedControlVerticalSpacing,
-                    views::kMaterialHorizontalMargin,
-                    views::kRelatedControlVerticalSpacing,
-                    views::kMaterialHorizontalMargin);
+  const int content_width =

[Roger Tawa OOO till Jul 10th, 2016/06/09 14:21:06]

|content_width| seems to be used only at line 1582 below.  Maybe move this
declaration closer to there.

+      GetFixedMenuWidth() - 2 * views::kMaterialHorizontalMargin;
+  views::GridLayout* layout =
+      CreateSingleColumnLayout(view, GetFixedMenuWidth());
+  layout->SetInsets(views::kRelatedControlVerticalSpacing, 0,
+                    views::kRelatedControlVerticalSpacing, 0);
+  current_profile_card_ = new BackgroundColorHoverButton(this);
 
   // Profile picture, left-aligned.
-  const int profile_bar_height = 56;
-  current_profile_photo_ = new EditableProfilePhoto(
+  EditableProfilePhoto* current_profile_photo = new EditableProfilePhoto(
       this, avatar_item.icon, !is_guest,
-      gfx::Rect(0, (profile_bar_height - kMediumImageSide) / 2,
+      gfx::Rect(0, (kProfileBarHeight - kMediumImageSide) / 2,
                 kMediumImageSide, kMediumImageSide));
-  SizedContainer* profile_container =
-      new SizedContainer(gfx::Size(column_width, profile_bar_height));
-  profile_container->AddChildView(current_profile_photo_);
+  current_profile_photo->SetX(views::kMaterialHorizontalMargin);
+  gfx::Rect photo_bounds = current_profile_photo->bounds();
+  current_profile_card_->AddChildView(current_profile_photo);
+  current_profile_photo->set_interactive(false);
 
   // Add supervised badge for supervised profile.
   if (browser_->profile()->IsSupervised()) {
     const int badge_spacing = 4;
     views::ImageView* supervised_icon = new views::ImageView();
     supervised_icon->SetImage(CreateBadgeForProfile(browser_->profile()));
     gfx::Size preferred_size = supervised_icon->GetPreferredSize();
-    gfx::Rect parent_bounds = current_profile_photo_->bounds();
     supervised_icon->SetBounds(
-        parent_bounds.right() - preferred_size.width() + badge_spacing,
-        parent_bounds.bottom() - preferred_size.height() + badge_spacing,
+        photo_bounds.right() - preferred_size.width() + badge_spacing,
+        photo_bounds.bottom() - preferred_size.height() + badge_spacing,
         preferred_size.width(),
         preferred_size.height());
-    profile_container->AddChildView(supervised_icon);
+    current_profile_card_->AddChildView(supervised_icon);
+    supervised_icon->set_interactive(false);
   }
 
   // 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);
-  gfx::Rect photo_bounds = current_profile_photo_->bounds();
-  const int textfield_left_margin =
-      kProfileHorizontalSpacing -
-          (editing_allowed ? kTextfieldLabelHorizontalSpacing : 0);
-  current_profile_name_->SetBounds(
-      photo_bounds.width() + textfield_left_margin,
+  views::Label* current_profile_name = new views::Label(
+      profiles::GetAvatarNameForProfile(browser_->profile()->GetPath()));
+  current_profile_name->SetFontList(
+      (&ui::ResourceBundle::GetSharedInstance())
+          ->GetFontList(ui::ResourceBundle::MediumFont));
+  current_profile_name->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  current_profile_name->SetBounds(
+      photo_bounds.right() + kProfileHorizontalSpacing,
       views::kRelatedControlVerticalSpacing,
-      profile_container->GetPreferredSize().width() - photo_bounds.width()
-          - textfield_left_margin,
-      profile_container->GetPreferredSize().height() / 2
-          - views::kRelatedControlVerticalSpacing);
-  profile_container->AddChildView(current_profile_name_);
+      GetFixedMenuWidth() - photo_bounds.right() - kProfileHorizontalSpacing -
+          views::kMaterialHorizontalMargin,
+      kProfileBarHeight / 2 - views::kRelatedControlVerticalSpacing);
+  current_profile_card_->AddChildView(current_profile_name);
 
-  // Center-align the avatar name if the profile is not signed in.
-  if (is_guest || !avatar_item.signed_in) {
-    current_profile_name_->SetY(
-      (profile_container->GetPreferredSize().height()
-          - current_profile_name_->height()) / 2);
+  if (avatar_item.signed_in && !switches::IsEnableAccountConsistency()) {
+    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);
+    email_label->SetBounds(
+        photo_bounds.right() + kProfileHorizontalSpacing,
+        kProfileBarHeight / 2,
+        GetFixedMenuWidth() - photo_bounds.right() - kProfileHorizontalSpacing -
+            views::kMaterialHorizontalMargin,
+        kProfileBarHeight / 2 - views::kRelatedControlVerticalSpacing);
+    current_profile_card_->AddChildView(email_label);
     layout->StartRow(1, 0);
-    layout->AddView(profile_container);
+    layout->AddView(current_profile_card_);
+    return view;
+  } else {
+    // Center-align the avatar name and add to the view.
+    current_profile_name->SetY(
+        (kProfileBarHeight - current_profile_name->height()) / 2);
+    layout->StartRow(1, 0);
+    layout->AddView(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) {
-    // Calculate the position and size for links available for signed-in
-    // profiles.
-    const int x_coordinate = photo_bounds.width() + kProfileHorizontalSpacing;
-    const int y_coordinate = profile_container->GetPreferredSize().height() / 2;
-    const int width = profile_container->GetPreferredSize().width()
-        - photo_bounds.width() - kProfileHorizontalSpacing;
-    const int height = profile_container->GetPreferredSize().height() / 2
-        - views::kRelatedControlVerticalSpacing;
-    layout->StartRow(1, 0);
-
-    if (switches::IsEnableAccountConsistency()) {
-      base::string16 link_title = 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);
-      manage_accounts_link_->SetBounds(
-          x_coordinate, y_coordinate, width, height);
-      profile_container->AddChildView(manage_accounts_link_);
-    } else {
-      // Badge the email address if there's an authentication error.
-      if (HasAuthError(browser_->profile())) {
-        auth_error_email_button_ =
-            new RightAlignedIconLabelButton(this, avatar_item.username);
-        auth_error_email_button_->SetElideBehavior(gfx::ELIDE_EMAIL);
-        auth_error_email_button_->SetImage(
-            views::LabelButton::STATE_NORMAL,
-            gfx::CreateVectorIcon(gfx::VectorIconId::WARNING, 12,
-                                  gfx::kChromeIconGrey));
-        auth_error_email_button_->SetFocusForPlatform();
-        auth_error_email_button_->set_request_focus_on_press(true);
-        gfx::Insets insets =
-            views::LabelButtonAssetBorder::GetDefaultInsetsForStyle(
-                views::Button::STYLE_TEXTBUTTON);
-        auth_error_email_button_->SetBorder(views::Border::CreateEmptyBorder(
-            insets.top(), insets.left(), insets.bottom(), insets.right()));
-        auth_error_email_button_->SetBounds(
-            x_coordinate - insets.left(), y_coordinate, width, height);
-        profile_container->AddChildView(auth_error_email_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);
-        email_label->SetBounds(x_coordinate, y_coordinate, width, height);
-        profile_container->AddChildView(email_label);
-      }
-    }
-    layout->AddView(profile_container);
-  } else {
+  if (!avatar_item.signed_in) {
     SigninManagerBase* signin_manager = SigninManagerFactory::GetForProfile(
         browser_->profile()->GetOriginalProfile());
-    if (signin_manager->IsSigninAllowed()) {
-      views::Label* promo = new views::Label(
-          l10n_util::GetStringUTF16(IDS_PROFILES_SIGNIN_PROMO));
-      promo->SetMultiLine(true);
-      promo->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-      layout->StartRowWithPadding(1, 0, 0,
-                                  views::kRelatedControlVerticalSpacing);
-      layout->StartRow(1, 0);
-      layout->AddView(promo);
+    if (!signin_manager->IsSigninAllowed())
+      return view;
+  }
 
-      signin_current_profile_link_ = new views::BlueButton(
+  // Add a layout with horizontal insets to accomodate the extra links under
+  // the active profile card.
+  views::View* links_view = new views::View();
+  views::GridLayout* links_layout =
+      CreateSingleColumnLayout(links_view, content_width);
+  links_layout->SetInsets(0, views::kMaterialHorizontalMargin,
+                          0, views::kMaterialHorizontalMargin);
+
+  if (avatar_item.signed_in) {
+    // Implies that account consistency is turned on
+    base::string16 link_title = 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);
+    links_layout->StartRowWithPadding(1, 0, 0,
+                                      views::kRelatedControlVerticalSpacing);
+    links_layout->StartRow(1, 0);
+    links_layout->AddView(manage_accounts_link_);
+  } else {
+    // Implies that account is not signed in and signin is allowed
+    views::Label* promo = new views::Label(
+        l10n_util::GetStringUTF16(IDS_PROFILES_SIGNIN_PROMO));
+    promo->SetMultiLine(true);
+    promo->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+    links_layout->StartRowWithPadding(1, 0, 0,
+                                      views::kRelatedControlVerticalSpacing);
+    links_layout->StartRow(1, 0);
+    links_layout->AddView(promo);
+    signin_current_profile_link_ = new views::BlueButton(
         this, l10n_util::GetStringFUTF16(IDS_SYNC_START_SYNC_BUTTON_LABEL,
             l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME)));
-      signin_current_profile_link_->SetMinSize(gfx::Size(0, 36));
-      layout->StartRowWithPadding(1, 0, 0,
-                                  views::kRelatedControlVerticalSpacing);
-      layout->StartRow(1, 0);
-      layout->AddView(signin_current_profile_link_);
-      content::RecordAction(
-          base::UserMetricsAction("Signin_Impression_FromAvatarBubbleSignin"));
-      layout->StartRowWithPadding(1, 0, 0,
-                                  views::kLabelToControlVerticalSpacing);
-    }
+    signin_current_profile_link_->SetMinSize(gfx::Size(0, 36));
+    links_layout->StartRowWithPadding(1, 0, 0,
+                                      views::kRelatedControlVerticalSpacing);
+    links_layout->StartRow(1, 0);
+    links_layout->AddView(signin_current_profile_link_);
+    content::RecordAction(
+        base::UserMetricsAction("Signin_Impression_FromAvatarBubbleSignin"));
+    links_layout->StartRowWithPadding(1, 0, 0,
+                                      views::kLabelToControlVerticalSpacing);
   }
+  layout->StartRow(1, 0);
+  layout->AddView(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);
   guest_avatar_item.active = true;
@@ skipping 448 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;
 }