Removing pre-material design menu setting.

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/app/vector_icons/vector_icons.h"
@@ skipping 63 matching lines @@
 #include "ui/views/controls/button/blue_button.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/button/md_text_button.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/separator.h"
 #include "ui/views/controls/styled_label.h"
-#include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 // 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 kMdImageSide = 40;
+const int kImageSide = 40;
+const int kProfileBadgeSize = 24;
+const int kFixedMenuWidth = 240;
+const int kSupervisedIconBadgeSize = 22;
+
+// The space between the right/bottom edge of the profile badge and the
+// right/bottom edge of the profile icon.
+const int kBadgeSpacing = 4;
 
 // Spacing between the edge of the material design user menu and the
 // top/bottom or left/right of the menu items.
-const int kMaterialMenuEdgeMargin = 16;
+const int kMenuEdgeMargin = 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;
 }
 
-int GetFixedMenuWidth() {
-  return switches::IsMaterialDesignUserMenu() ? 240 : 250;
-}
-
-int GetProfileBadgeSize() {
-  return switches::IsMaterialDesignUserMenu() ? 24 : 30;
-}
-
 // DEPRECATED: New user menu components should use views::BoxLayout instead.
 // Creates a GridLayout with a single column. This ensures that all the child
 // views added get auto-expanded to fill the full width of the bubble.
 views::GridLayout* CreateSingleColumnLayout(views::View* view, int width) {
   views::GridLayout* layout = new views::GridLayout(view);
   view->SetLayoutManager(layout);
 
   views::ColumnSet* columns = layout->AddColumnSet(0);
   columns->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 0,
                      views::GridLayout::FIXED, width, width);
   return layout;
 }
 
 views::Link* CreateLink(const base::string16& link_text,
                         views::LinkListener* listener) {
   views::Link* link_button = new views::Link(link_text);
   link_button->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   link_button->SetUnderline(false);
   link_button->set_listener(listener);
   return link_button;
 }
 
-gfx::ImageSkia CreateSquarePlaceholderImage(int size) {
-  SkBitmap bitmap;
-  bitmap.allocPixels(SkImageInfo::MakeA8(size, size));
-  bitmap.eraseARGB(0, 0, 0, 0);
-  return gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
-}
-
 bool HasAuthError(Profile* profile) {
   const SigninErrorController* error =
       SigninErrorControllerFactory::GetForProfile(profile);
   return error && error->HasError();
 }
 
 std::string GetAuthErrorAccountId(Profile* profile) {
   const SigninErrorController* error =
       SigninErrorControllerFactory::GetForProfile(profile);
   if (!error)
@@ skipping 26 matching lines @@
  public:
   BackgroundColorHoverButton(ProfileChooserView* profile_chooser_view,
                              const base::string16& text)
       : views::LabelButton(profile_chooser_view, text),
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
         profile_chooser_view_(profile_chooser_view),
 #endif
         title_(nullptr),
         subtitle_(nullptr) {
     DCHECK(profile_chooser_view);
-    SetImageLabelSpacing(switches::IsMaterialDesignUserMenu()
-                             ? (kMaterialMenuEdgeMargin - 2)
-                             : views::kItemLabelSpacing);
-    const int button_margin = switches::IsMaterialDesignUserMenu()
-                                  ? kMaterialMenuEdgeMargin
-                                  : views::kButtonHEdgeMarginNew;
-    SetBorder(views::CreateEmptyBorder(0, button_margin, 0, button_margin));
+    SetImageLabelSpacing(kMenuEdgeMargin - 2);
+    SetBorder(views::CreateEmptyBorder(0, kMenuEdgeMargin, 0, kMenuEdgeMargin));
     SetFocusForPlatform();
 
-    if (switches::IsMaterialDesignUserMenu()) {
-      label()->SetHandlesTooltips(false);
-    }
+    label()->SetHandlesTooltips(false);
   }
 
   BackgroundColorHoverButton(ProfileChooserView* profile_chooser_view,
                              const base::string16& text,
                              const gfx::ImageSkia& icon)
       : BackgroundColorHoverButton(profile_chooser_view, text) {
     SetMinSize(gfx::Size(
         icon.width(), kButtonHeight + views::kRelatedControlVerticalSpacing));
     SetImage(STATE_NORMAL, icon);
   }
@@ skipping 133 matching lines @@
   title_widget_->SetContentsView(title_view_);
 
   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 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(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();
-    label_bounds.Inset(content_bounds.x() - label_bounds.x(), 0, 0, 0);
-    label()->SetBoundsRect(label_bounds);
-  }
-
- private:
-  void OnFocus() override {
-    SetState(STATE_HOVERED);
-  }
-
-  void OnBlur() override {
-    SetState(STATE_NORMAL);
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(RightAlignedIconLabelButton);
-};
-
 // EditableProfilePhoto -------------------------------------------------
 
-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());
+    set_can_process_events_within_subtree(false);
+    gfx::Image image =
+        profiles::GetSizedAvatarIcon(icon, true, kImageSide, kImageSide);
     SetImage(views::LabelButton::STATE_NORMAL, *image.ToImageSkia());
     SetBorder(views::NullBorder());
-    if (switches::IsMaterialDesignUserMenu()) {
-      SetMinSize(gfx::Size(GetPreferredSize().width() + badge_spacing(),
-                           GetPreferredSize().height() + badge_spacing() +
-                               views::kRelatedControlSmallVerticalSpacing));
-    } else {
-      SetSize(GetPreferredSize());
-    }
+    SetMinSize(gfx::Size(GetPreferredSize().width() + kBadgeSpacing,
+                         GetPreferredSize().height() + kBadgeSpacing +
+                             views::kRelatedControlSmallVerticalSpacing));
 
-    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(
-        kPhotoCameraIcon, 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_);
+    SetEnabled(false);
   }
 
   void PaintChildren(const ui::PaintContext& context) override {
     {
       // Display any children (the "change photo" overlay) as a circle.
       ui::ClipRecorder clip_recorder(context);
       gfx::Rect clip_bounds = image()->GetMirroredBounds();
       gfx::Path clip_mask;
       clip_mask.addCircle(
           clip_bounds.x() + clip_bounds.width() / 2,
           clip_bounds.y() + clip_bounds.height() / 2,
           clip_bounds.width() / 2);
       clip_recorder.ClipPathWithAntiAliasing(clip_mask);
       View::PaintChildren(context);
     }
 
     ui::PaintRecorder paint_recorder(
-        context, gfx::Size(GetProfileBadgeSize(), GetProfileBadgeSize()));
+        context, gfx::Size(kProfileBadgeSize, kProfileBadgeSize));
     gfx::Canvas* canvas = paint_recorder.canvas();
     if (profile_->IsSupervised()) {
-      gfx::Rect bounds(0, 0, GetProfileBadgeSize(), GetProfileBadgeSize());
-      int badge_offset =
-          icon_image_side() + badge_spacing() - GetProfileBadgeSize();
+      gfx::Rect bounds(0, 0, kProfileBadgeSize, kProfileBadgeSize);
+      int badge_offset = kImageSide + kBadgeSpacing - kProfileBadgeSize;
       gfx::Vector2d badge_offset_vector = gfx::Vector2d(
-          GetMirroredXWithWidthInView(badge_offset, GetProfileBadgeSize()),
-          badge_offset + (switches::IsMaterialDesignUserMenu()
-                              ? views::kRelatedControlSmallVerticalSpacing
-                              : 0));
+          GetMirroredXWithWidthInView(badge_offset, kProfileBadgeSize),
+          badge_offset + views::kRelatedControlSmallVerticalSpacing);
 
       gfx::Point center_point = bounds.CenterPoint() + badge_offset_vector;
 
       // Paint the circular background.
       cc::PaintFlags flags;
       flags.setAntiAlias(true);
       flags.setColor(GetNativeTheme()->GetSystemColor(
           ui::NativeTheme::kColorId_BubbleBackground));
-      canvas->DrawCircle(center_point, GetProfileBadgeSize() / 2, flags);
+      canvas->DrawCircle(center_point, kProfileBadgeSize / 2, flags);
 
-      const gfx::VectorIcon* icon;
-      int icon_size;
-      SkColor icon_color;
-      if (switches::IsMaterialDesignUserMenu()) {
-        icon = profile_->IsChild() ? &kAccountChildCircleIcon
-                                   : &kSupervisorAccountCircleIcon;
-        icon_size = 22;
-        icon_color = gfx::kChromeIconGrey;
-      } else {
-        // Paint the light blue circle.
-        flags.setColor(SkColorSetRGB(0xaf, 0xd9, 0xfc));
-        canvas->DrawCircle(
-            center_point, GetProfileBadgeSize() / 2 - kProfileBadgeWhitePadding,
-            flags);
-
-        icon =
-            profile_->IsChild() ? &kAccountChildIcon : &kSupervisorAccountIcon;
-        icon_size = profile_->IsChild() ? 26 : 20;
-        icon_color = SkColorSetRGB(0, 0x66, 0xff);
-      }
+      const gfx::VectorIcon* icon = profile_->IsChild()
+                                        ? &kAccountChildCircleIcon
+                                        : &kSupervisorAccountCircleIcon;
 
       // Paint the badge icon.
-      int offset = (GetProfileBadgeSize() - icon_size) / 2;
+      int offset = (kProfileBadgeSize - kSupervisedIconBadgeSize) / 2;
       canvas->Translate(badge_offset_vector + gfx::Vector2d(offset, offset));
-      gfx::PaintVectorIcon(canvas, *icon, icon_size, icon_color);
+      gfx::PaintVectorIcon(canvas, *icon, kSupervisedIconBadgeSize,
+                           gfx::kChromeIconGrey);
     }
   }
 
-  static int icon_image_side() {
-    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(ButtonState old_state) override {
     if (photo_overlay_) {
       photo_overlay_->SetVisible(
           state() == STATE_PRESSED || state() == STATE_HOVERED || HasFocus());
     }
   }
 
   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_;
-
   // 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::CreateEmptyBorder(textfield_border_insets));
-      name_label->SetFontList(medium_font_list);
-      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(gfx::ALIGN_CENTER);
-    profile_name_textfield_->SetVisible(false);
-    AddChildView(profile_name_textfield_);
-
-    button_ = new RightAlignedIconLabelButton(this, text);
-    button_->SetFontListDeprecated(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(kModeEditIcon, kIconSize,
-                                            SkColorSetRGB(0x33, 0x33, 0x33)));
-    button_->SetImage(views::LabelButton::STATE_PRESSED,
-                      gfx::CreateVectorIcon(kModeEditIcon, 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.
-    const int kIconTextLabelButtonSpacing = 5;
-    button_->SetBorder(views::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);
-    profile_name_textfield_->SetVisible(false);
-  }
-
- private:
-  // views::ButtonListener:
-  void ButtonPressed(views::Button* sender, const ui::Event& event) override {
-    button_->SetVisible(false);
-    profile_name_textfield_->SetVisible(true);
-    profile_name_textfield_->SetText(button_->GetText());
-    profile_name_textfield_->SelectAll(false);
-    profile_name_textfield_->RequestFocus();
-    // Re-layouts the view after swaping the controls.
-    Layout();
-  }
-
-  // views::LabelButton:
-  bool OnKeyReleased(const ui::KeyEvent& event) override {
-    // Override CustomButton's implementation, which presses the button when
-    // you press space and clicks it when you release space, as the space can be
-    // part of the new profile name typed in the textfield.
-    return false;
-  }
-
-  // The label button which shows the profile name, and can handle the event to
-  // make it editable. Can be NULL if the profile name isn't allowed to be
-  // edited.
-  RightAlignedIconLabelButton* button_;
-
-  // Textfield that is shown when editing the profile name. Can be NULL if
-  // the profile name isn't allowed to be edited (e.g. for guest profiles).
-  views::Textfield* profile_name_textfield_;
-
-  DISALLOW_COPY_AND_ASSIGN(EditableProfileName);
-};
-
 // A title card with one back button right aligned and one label center aligned.
 class TitleCard : public views::View {
  public:
   TitleCard(const base::string16& message, views::ButtonListener* listener,
             views::ImageButton** back_button) {
     back_button_ = CreateBackButton(listener);
     *back_button = back_button_;
 
     title_label_ = new views::Label(message);
     title_label_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
@@ skipping 73 matching lines @@
     const signin::ManageAccountsParams& manage_accounts_params,
     signin_metrics::AccessPoint access_point,
     views::View* anchor_view,
     Browser* browser,
     bool is_source_keyboard) {
   // Don't start creating the view if it would be an empty fast user switcher.
   // It has to happen here to prevent the view system from creating an empty
   // container.
   // Same for material design user menu since fast profile switcher will be
   // migrated to the left-click menu.
-  if (view_mode == profiles::BUBBLE_VIEW_MODE_FAST_PROFILE_CHOOSER &&
-      (!profiles::HasProfileSwitchTargets(browser->profile()) ||
-       switches::IsMaterialDesignUserMenu())) {
+  if (view_mode == profiles::BUBBLE_VIEW_MODE_FAST_PROFILE_CHOOSER)
     return;
-  }
 
   if (IsShowing()) {
     if (tutorial_mode != profiles::TUTORIAL_MODE_NONE) {
       profile_bubble_->tutorial_mode_ = tutorial_mode;
       profile_bubble_->ShowViewFromMode(view_mode);
     }
     return;
   }
 
   profile_bubble_ =
@@ skipping 56 matching lines @@
   tutorial_learn_more_link_ = nullptr;
   sync_error_signin_button_ = nullptr;
   sync_error_passphrase_button_ = nullptr;
   sync_error_upgrade_button_ = nullptr;
   sync_error_signin_again_button_ = nullptr;
   sync_error_signout_button_ = nullptr;
   manage_accounts_link_ = nullptr;
   manage_accounts_button_ = nullptr;
   signin_current_profile_button_ = nullptr;
   auth_error_email_button_ = nullptr;
-  current_profile_photo_ = nullptr;
-  current_profile_name_ = nullptr;
   current_profile_card_ = nullptr;
   first_profile_button_ = 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;
@@ skipping 124 matching lines @@
       break;
     case profiles::BUBBLE_VIEW_MODE_SWITCH_USER:
       layout = CreateSingleColumnLayout(this, kFixedSwitchUserViewWidth);
       sub_view = CreateSwitchUserView();
       ProfileMetrics::LogProfileNewAvatarMenuNotYou(
           ProfileMetrics::PROFILE_AVATAR_MENU_NOT_YOU_VIEW);
       break;
     case profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT:
     case profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER:
     case profiles::BUBBLE_VIEW_MODE_FAST_PROFILE_CHOOSER:
-      layout = CreateSingleColumnLayout(this, GetFixedMenuWidth());
+      layout = CreateSingleColumnLayout(this, kFixedMenuWidth);
       sub_view = CreateProfileChooserView(avatar_menu);
       break;
   }
   // Clears tutorial mode for all non-profile-chooser views.
   if (view_mode_ != profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER)
     tutorial_mode_ = profiles::TUTORIAL_MODE_NONE;
 
   layout->StartRow(1, 0);
   layout->AddView(sub_view);
   Layout();
@@ skipping 123 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_) {
-    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);
@@ skipping 79 matching lines @@
     signin_ui_util::ShowSigninErrorLearnMorePage(browser_->profile());
   }
 }
 
 void ProfileChooserView::StyledLabelLinkClicked(views::StyledLabel* label,
                                                 const gfx::Range& range,
                                                 int event_flags) {
   chrome::ShowSettings(browser_);
 }
 
-bool ProfileChooserView::HandleKeyEvent(views::Textfield* sender,
-                                        const ui::KeyEvent& key_event) {
-  if (key_event.type() != ui::ET_KEY_PRESSED)
-    return false;
-
-  views::Textfield* name_textfield =
-      current_profile_name_->profile_name_textfield();
-  DCHECK(sender == name_textfield);
-
-  if (key_event.key_code() == ui::VKEY_RETURN ||
-      key_event.key_code() == ui::VKEY_TAB) {
-    // Pressing Tab/Enter commits the new profile name, unless it's empty.
-    base::string16 new_profile_name = name_textfield->text();
-    base::TrimWhitespace(new_profile_name, base::TRIM_ALL, &new_profile_name);
-    if (new_profile_name.empty())
-      return true;
-
-    const AvatarMenu::Item& active_item = avatar_menu_->GetItemAt(
-        avatar_menu_->GetActiveProfileIndex());
-    Profile* profile = g_browser_process->profile_manager()->GetProfile(
-        active_item.profile_path);
-    DCHECK(profile);
-
-    if (profile->IsLegacySupervised())
-      return true;
-
-    profiles::UpdateProfileName(profile, new_profile_name);
-    PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_NAME);
-    current_profile_name_->ShowReadOnlyView();
-    return true;
-  }
-  return false;
-}
-
 void ProfileChooserView::PopulateCompleteProfileChooserView(
     views::GridLayout* layout,
     AvatarMenu* avatar_menu) {
   // Separate items into active and alternatives.
   Indexes other_profiles;
   views::View* tutorial_view = NULL;
   views::View* sync_error_view = NULL;
   views::View* current_profile_view = NULL;
   views::View* current_profile_accounts = NULL;
   views::View* option_buttons_view = NULL;
   for (size_t i = 0; i < avatar_menu->GetNumberOfItems(); ++i) {
     const AvatarMenu::Item& item = avatar_menu->GetItemAt(i);
     if (item.active) {
       option_buttons_view = CreateOptionsView(
           item.signed_in && profiles::IsLockAvailable(browser_->profile()),
           avatar_menu);
-      current_profile_view =
-          switches::IsMaterialDesignUserMenu()
-              ? CreateMaterialDesignCurrentProfileView(item, false)
-              : CreateCurrentProfileView(item, false);
-      if (IsProfileChooser(view_mode_)) {
-        if (!switches::IsMaterialDesignUserMenu())
-          tutorial_view = CreateTutorialViewIfNeeded(item);
-      } else {
+      current_profile_view = CreateCurrentProfileView(item, false);
+      if (!IsProfileChooser(view_mode_))
         current_profile_accounts = CreateCurrentProfileAccountsView(item);
-      }
-      if (switches::IsMaterialDesignUserMenu())
-        sync_error_view = CreateSyncErrorViewIfNeeded();
+      sync_error_view = CreateSyncErrorViewIfNeeded();
     } else {
       other_profiles.push_back(i);
     }
   }
 
   if (tutorial_view) {
     // TODO(mlerman): update UMA stats for the new tutorial.
     layout->StartRow(1, 0);
     layout->AddView(tutorial_view);
   } else {
@@ skipping 18 matching lines @@
 
   if (!IsProfileChooser(view_mode_)) {
     DCHECK(current_profile_accounts);
     layout->StartRow(0, 0);
     layout->AddView(new views::Separator());
     layout->StartRow(1, 0);
     layout->AddView(current_profile_accounts);
   }
 
   if (browser_->profile()->IsSupervised()) {
-    if (!switches::IsMaterialDesignUserMenu()) {
-      layout->StartRow(0, 0);
-      layout->AddView(new views::Separator());
-    }
     layout->StartRow(1, 0);
     layout->AddView(CreateSupervisedUserDisclaimerView());
   }
 
   layout->StartRow(0, 0);
   layout->AddView(new views::Separator());
 
   if (option_buttons_view) {
     layout->StartRow(0, 0);
     layout->AddView(option_buttons_view);
@@ skipping 11 matching lines @@
     }
   }
 
   layout->StartRow(1, 0);
   layout->AddView(CreateOtherProfilesView(other_profiles));
 }
 
 views::View* ProfileChooserView::CreateProfileChooserView(
     AvatarMenu* avatar_menu) {
   views::View* view = new views::View();
-  views::GridLayout* layout =
-      CreateSingleColumnLayout(view, GetFixedMenuWidth());
+  views::GridLayout* layout = CreateSingleColumnLayout(view, kFixedMenuWidth);
 
   if (view_mode_ == profiles::BUBBLE_VIEW_MODE_FAST_PROFILE_CHOOSER) {
     PopulateMinimalProfileChooserView(layout, avatar_menu);
     // The user is using right-click switching, no need to tell them about it.
     PrefService* local_state = g_browser_process->local_state();
     local_state->SetBoolean(
         prefs::kProfileAvatarRightClickTutorialDismissed, true);
   } else {
     PopulateCompleteProfileChooserView(layout, avatar_menu);
   }
@@ skipping 55 matching lines @@
     bool stack_button,
     views::Link** link,
     views::LabelButton** button,
     views::ImageButton** close_button) {
   tutorial_mode_ = tutorial_mode;
 
   views::View* view = new views::View();
   view->set_background(views::Background::CreateSolidBackground(
       profiles::kAvatarTutorialBackgroundColor));
   views::GridLayout* layout = CreateSingleColumnLayout(
-      view, GetFixedMenuWidth() - 2 * views::kButtonHEdgeMarginNew);
+      view, kFixedMenuWidth - 2 * views::kButtonHEdgeMarginNew);
   // Creates a second column set for buttons and links.
   views::ColumnSet* button_columns = layout->AddColumnSet(1);
   button_columns->AddColumn(views::GridLayout::LEADING,
       views::GridLayout::CENTER, 0, views::GridLayout::USE_PREF, 0, 0);
   button_columns->AddPaddingColumn(
       1, views::kUnrelatedControlHorizontalSpacing);
   button_columns->AddColumn(views::GridLayout::TRAILING,
       views::GridLayout::CENTER, 0, views::GridLayout::USE_PREF, 0, 0);
   layout->SetInsets(views::kButtonVEdgeMarginNew,
                     views::kButtonHEdgeMarginNew,
@@ skipping 111 matching lines @@
       break;
     case sync_ui_util::NO_SYNC_ERROR:
       return nullptr;
     default:
       NOTREACHED();
   }
 
   // Sets an overall horizontal layout.
   views::View* view = new views::View();
   views::BoxLayout* layout = new views::BoxLayout(
-      views::BoxLayout::kHorizontal, kMaterialMenuEdgeMargin,
-      kMaterialMenuEdgeMargin, views::kUnrelatedControlHorizontalSpacing);
+      views::BoxLayout::kHorizontal, kMenuEdgeMargin, kMenuEdgeMargin,
+      views::kUnrelatedControlHorizontalSpacing);
   layout->set_cross_axis_alignment(
       views::BoxLayout::CROSS_AXIS_ALIGNMENT_START);
   view->SetLayoutManager(layout);
 
   // Adds the sync problem icon.
   views::ImageView* sync_problem_icon = new views::ImageView();
   sync_problem_icon->SetImage(
       gfx::CreateVectorIcon(kSyncProblemIcon, 20, gfx::kGoogleRed700));
   view->AddChildView(sync_problem_icon);
 
@@ skipping 38 matching lines @@
   }
 
   view->AddChildView(vertical_view);
   return view;
 }
 
 views::View* ProfileChooserView::CreateCurrentProfileView(
     const AvatarMenu::Item& avatar_item,
     bool is_guest) {
   views::View* view = new views::View();
-  int column_width = GetFixedMenuWidth() - 2 * views::kButtonHEdgeMarginNew;
-  views::GridLayout* layout = CreateSingleColumnLayout(view, column_width);
-  layout->SetInsets(views::kButtonVEdgeMarginNew,
-                    views::kButtonHEdgeMarginNew,
-                    views::kUnrelatedControlVerticalSpacing,
-                    views::kButtonHEdgeMarginNew);
-
-  // Profile icon, centered.
-  int x_offset = (column_width - kLargeImageSide) / 2;
-  current_profile_photo_ = new EditableProfilePhoto(
-      this, avatar_item.icon, !is_guest, browser_->profile());
-  current_profile_photo_->SetX(x_offset);
-  SizedContainer* profile_icon_container =
-      new SizedContainer(gfx::Size(column_width, kLargeImageSide));
-  profile_icon_container->AddChildView(current_profile_photo_);
-
-
-  layout->StartRow(1, 0);
-  layout->AddView(profile_icon_container);
-
-  // Profile name, centered.
-  bool editing_allowed = !is_guest &&
-                         !browser_->profile()->IsLegacySupervised();
-  current_profile_name_ = new EditableProfileName(
-      this,
-      profiles::GetAvatarNameForProfile(browser_->profile()->GetPath()),
-      editing_allowed);
-  layout->StartRowWithPadding(1, 0, 0,
-                              views::kRelatedControlSmallVerticalSpacing);
-  layout->StartRow(1, 0);
-  layout->AddView(current_profile_name_);
-
-  if (is_guest)
-    return view;
-
-  // The available links depend on the type of profile that is active.
-  if (avatar_item.signed_in) {
-    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_CENTER);
-      layout->AddView(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(ui::kWarningIcon, 18, gfx::kChromeIconGrey));
-        auth_error_email_button_->SetFocusForPlatform();
-        gfx::Insets insets =
-            views::LabelButtonAssetBorder::GetDefaultInsetsForStyle(
-                views::Button::STYLE_TEXTBUTTON);
-        auth_error_email_button_->SetBorder(views::CreateEmptyBorder(
-            insets.top(), insets.left(), insets.bottom(), insets.right()));
-        layout->AddView(auth_error_email_button_);
-      } else {
-        // Add a small padding between the email button and the profile name.
-        layout->StartRowWithPadding(1, 0, 0, 2);
-        views::Label* email_label = new views::Label(avatar_item.username);
-        email_label->SetElideBehavior(gfx::ELIDE_EMAIL);
-        email_label->SetEnabled(false);
-        layout->AddView(email_label);
-      }
-    }
-  } else {
-    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::kRelatedControlSmallVerticalSpacing);
-      layout->StartRow(1, 0);
-      layout->AddView(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)));
-      layout->StartRowWithPadding(1, 0, 0,
-                                  views::kRelatedControlVerticalSpacing);
-      layout->StartRow(1, 0);
-      layout->AddView(signin_current_profile_button_);
-      content::RecordAction(
-          base::UserMetricsAction("Signin_Impression_FromAvatarBubbleSignin"));
-    }
-  }
-
-  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, 0,
                            views::kRelatedControlVerticalSpacing, 0));
 
   // Container for the profile photo and avatar/user name.
   BackgroundColorHoverButton* current_profile_card =
       new BackgroundColorHoverButton(this, base::string16());
   views::GridLayout* grid_layout = new views::GridLayout(current_profile_card);
   current_profile_card->SetLayoutManager(grid_layout);
   views::ColumnSet* columns = grid_layout->AddColumnSet(0);
-  columns->AddPaddingColumn(0, kMaterialMenuEdgeMargin);
+  columns->AddPaddingColumn(0, kMenuEdgeMargin);
   columns->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 0,
                      views::GridLayout::USE_PREF, 0, 0);
-  columns->AddPaddingColumn(
-      0, kMaterialMenuEdgeMargin - EditableProfilePhoto::badge_spacing());
+  columns->AddPaddingColumn(0, kMenuEdgeMargin - kBadgeSpacing);
   columns->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
                      views::GridLayout::USE_PREF, 0, 0);
-  columns->AddPaddingColumn(0, kMaterialMenuEdgeMargin);
+  columns->AddPaddingColumn(0, kMenuEdgeMargin);
   grid_layout->AddPaddingRow(0, 0);
   const int num_labels =
       (avatar_item.signed_in && !switches::IsEnableAccountConsistency()) ? 2
                                                                          : 1;
-  int profile_card_height = EditableProfilePhoto::icon_image_side() +
-                            2 *
-                                (EditableProfilePhoto::badge_spacing() +
-                                 views::kRelatedControlSmallVerticalSpacing);
+  int profile_card_height =
+      kImageSide +
+      2 * (kBadgeSpacing + views::kRelatedControlSmallVerticalSpacing);
   const int line_height = profile_card_height / num_labels;
   grid_layout->StartRow(0, 0, line_height);
   current_profile_card_ = current_profile_card;
 
   // Profile picture, left-aligned.
   EditableProfilePhoto* current_profile_photo = new EditableProfilePhoto(
       this, avatar_item.icon, !is_guest, browser_->profile());
 
   // Profile name, left-aligned to the right of profile icon.
   views::Label* current_profile_name = new views::Label(
       profiles::GetAvatarNameForProfile(browser_->profile()->GetPath()));
   current_profile_card->set_title(current_profile_name);
   current_profile_name->SetAutoColorReadabilityEnabled(false);
   current_profile_name->SetFontList(
       ui::ResourceBundle::GetSharedInstance().GetFontListWithDelta(
           1, gfx::Font::FontStyle::NORMAL, gfx::Font::Weight::MEDIUM));
   current_profile_name->SetHorizontalAlignment(gfx::ALIGN_LEFT);
 
   // The grid layout contains one row if not signed in or account consistency is
   // enabled. It contains 2 rows if signed in and account consistency is
   // disabled (the second row is for the email label). For the second case the
   // profile photo has to be over 2 rows.
   grid_layout->AddView(current_profile_photo, 1, num_labels);
   grid_layout->AddView(current_profile_name, 1, 1, views::GridLayout::LEADING,
                        (num_labels == 2) ? views::GridLayout::TRAILING
                                          : views::GridLayout::CENTER);
   current_profile_card_->SetMinSize(gfx::Size(
-      GetFixedMenuWidth(), current_profile_photo->GetPreferredSize().height() +
-                               2 * views::kRelatedControlSmallVerticalSpacing));
+      kFixedMenuWidth, current_profile_photo->GetPreferredSize().height() +
+                           2 * views::kRelatedControlSmallVerticalSpacing));
   view->AddChildView(current_profile_card_);
 
   if (is_guest) {
     current_profile_card_->SetEnabled(false);
     return view;
   }
 
   const base::string16 profile_name =
       profiles::GetAvatarNameForProfile(browser_->profile()->GetPath());
 
   // The available links depend on the type of profile that is active.
   if (avatar_item.signed_in) {
     if (switches::IsEnableAccountConsistency()) {
       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_button_ =
           new BackgroundColorHoverButton(this, button_text);
       manage_accounts_button_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
       manage_accounts_button_->SetMinSize(
-          gfx::Size(GetFixedMenuWidth(), kButtonHeight));
+          gfx::Size(kFixedMenuWidth, kButtonHeight));
       view->AddChildView(manage_accounts_button_);
     } else {
       views::Label* email_label = new views::Label(avatar_item.username);
       current_profile_card->set_subtitle(email_label);
       email_label->SetAutoColorReadabilityEnabled(false);
       email_label->SetElideBehavior(gfx::ELIDE_EMAIL);
       email_label->SetEnabled(false);
       email_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
       grid_layout->StartRow(1, 0);
       // Skip first column for the profile icon.
       grid_layout->SkipColumns(1);
       grid_layout->AddView(email_label, 1, 1, views::GridLayout::LEADING,
                            views::GridLayout::LEADING);
     }
 
     current_profile_card_->SetAccessibleName(
         l10n_util::GetStringFUTF16(
             IDS_PROFILES_EDIT_SIGNED_IN_PROFILE_ACCESSIBLE_NAME,
             profile_name,
             avatar_item.username));
     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);
+        views::BoxLayout::kVertical, kMenuEdgeMargin,
+        views::kRelatedControlVerticalSpacing, kMenuEdgeMargin);
     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);
     extra_links_view->AddChildView(promo);
 
     signin_current_profile_button_ =
@@ skipping 18 matching lines @@
 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;
   guest_avatar_item.name = l10n_util::GetStringUTF16(
       IDS_PROFILES_GUEST_PROFILE_NAME);
   guest_avatar_item.signed_in = false;
 
-  return switches::IsMaterialDesignUserMenu()
-             ? CreateMaterialDesignCurrentProfileView(guest_avatar_item, true)
-             : CreateCurrentProfileView(guest_avatar_item, true);
+  return CreateCurrentProfileView(guest_avatar_item, true);
 }
 
 views::View* ProfileChooserView::CreateOtherProfilesView(
     const Indexes& avatars_to_show) {
   views::View* view = new views::View();
-  views::GridLayout* layout =
-      CreateSingleColumnLayout(view, GetFixedMenuWidth());
+  views::GridLayout* layout = CreateSingleColumnLayout(view, kFixedMenuWidth);
 
   for (size_t index : avatars_to_show) {
     const AvatarMenu::Item& item = avatar_menu_->GetItemAt(index);
     const int kSmallImageSide = 32;
 
     // Use the low-res, small default avatars in the fast user switcher, like
     // we do in the menu bar.
     gfx::Image item_icon;
     AvatarMenu::GetImageForMenuButton(item.profile_path, &item_icon);
 
@@ skipping 11 matching lines @@
     layout->StartRow(1, 0);
     layout->AddView(button);
   }
 
   return view;
 }
 
 views::View* ProfileChooserView::CreateOptionsView(bool display_lock,
                                                    AvatarMenu* avatar_menu) {
   views::View* view = new views::View();
-  views::GridLayout* layout =
-      CreateSingleColumnLayout(view, GetFixedMenuWidth());
+  views::GridLayout* layout = CreateSingleColumnLayout(view, kFixedMenuWidth);
 
   const bool is_guest = browser_->profile()->IsGuestSession();
-  const int kIconSize = switches::IsMaterialDesignUserMenu() ? 20 : 16;
-  if (switches::IsMaterialDesignUserMenu()) {
-    // Add the user switching buttons
-    const int kProfileIconSize = 18;
-    layout->StartRowWithPadding(1, 0, 0, views::kRelatedControlVerticalSpacing);
-    for (size_t i = 0; i < avatar_menu->GetNumberOfItems(); ++i) {
-      const AvatarMenu::Item& item = avatar_menu->GetItemAt(i);
-      if (!item.active) {
-        gfx::Image image = profiles::GetSizedAvatarIcon(
-            item.icon, true, kProfileIconSize, kProfileIconSize,
-            profiles::SHAPE_CIRCLE);
-        views::LabelButton* button = new BackgroundColorHoverButton(
-            this, profiles::GetProfileSwitcherTextForItem(item),
-            *image.ToImageSkia());
-        button->SetImageLabelSpacing(kMaterialMenuEdgeMargin);
-        open_other_profile_indexes_map_[button] = i;
+  const int kIconSize = 20;
+  // Add the user switching buttons
+  const int kProfileIconSize = 18;
+  layout->StartRowWithPadding(1, 0, 0, views::kRelatedControlVerticalSpacing);
+  for (size_t i = 0; i < avatar_menu->GetNumberOfItems(); ++i) {
+    const AvatarMenu::Item& item = avatar_menu->GetItemAt(i);
+    if (!item.active) {
+      gfx::Image image = profiles::GetSizedAvatarIcon(
+          item.icon, true, kProfileIconSize, kProfileIconSize,
+          profiles::SHAPE_CIRCLE);
+      views::LabelButton* button = new BackgroundColorHoverButton(
+          this, profiles::GetProfileSwitcherTextForItem(item),
+          *image.ToImageSkia());
+      button->SetImageLabelSpacing(kMenuEdgeMargin);
+      open_other_profile_indexes_map_[button] = i;
 
-        if (!first_profile_button_)
-          first_profile_button_ = button;
-        layout->StartRow(1, 0);
-        layout->AddView(button);
-      }
+      if (!first_profile_button_)
+        first_profile_button_ = button;
+      layout->StartRow(1, 0);
+      layout->AddView(button);
     }
+  }
 
-    // Add the "Guest" button for browsing as guest
-    if (!is_guest) {
-      PrefService* service = g_browser_process->local_state();
-      DCHECK(service);
-      if (service->GetBoolean(prefs::kBrowserGuestModeEnabled)) {
-        guest_profile_button_ = new BackgroundColorHoverButton(
-            this, l10n_util::GetStringUTF16(IDS_GUEST_PROFILE_NAME),
-            gfx::CreateVectorIcon(kAccountCircleIcon, kIconSize,
-                                  gfx::kChromeIconGrey));
-        layout->StartRow(1, 0);
-        layout->AddView(guest_profile_button_);
-      }
+  // Add the "Guest" button for browsing as guest
+  if (!is_guest) {
+    PrefService* service = g_browser_process->local_state();
+    DCHECK(service);
+    if (service->GetBoolean(prefs::kBrowserGuestModeEnabled)) {
+      guest_profile_button_ = new BackgroundColorHoverButton(
+          this, l10n_util::GetStringUTF16(IDS_GUEST_PROFILE_NAME),
+          gfx::CreateVectorIcon(kAccountCircleIcon, kIconSize,
+                                gfx::kChromeIconGrey));
+      layout->StartRow(1, 0);
+      layout->AddView(guest_profile_button_);
     }
   }
 
   base::string16 text = l10n_util::GetStringUTF16(
-      is_guest ? IDS_PROFILES_EXIT_GUEST
-               : (switches::IsMaterialDesignUserMenu()
-                      ? IDS_PROFILES_MANAGE_USERS_BUTTON
-                      : IDS_PROFILES_SWITCH_USERS_BUTTON));
+      is_guest ? IDS_PROFILES_EXIT_GUEST : IDS_PROFILES_MANAGE_USERS_BUTTON);
   const gfx::VectorIcon& settings_icon =
-      switches::IsMaterialDesignUserMenu()
-          ? (is_guest ? kCloseAllIcon : kSettingsIcon)
-          : kAccountBoxIcon;
+      is_guest ? kCloseAllIcon : kSettingsIcon;
   users_button_ = new BackgroundColorHoverButton(
       this, text,
       gfx::CreateVectorIcon(settings_icon, kIconSize, gfx::kChromeIconGrey));
 
   layout->StartRow(1, 0);
   layout->AddView(users_button_);
 
-  if (!switches::IsMaterialDesignUserMenu() && ShouldShowGoIncognito()) {
-    layout->StartRow(1, 0);
-    layout->AddView(new views::Separator());
-
-    ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
-    go_incognito_button_ = new BackgroundColorHoverButton(
-        this,
-        l10n_util::GetStringUTF16(IDS_PROFILES_GO_INCOGNITO_BUTTON),
-        *rb->GetImageSkiaNamed(IDR_ICON_PROFILES_MENU_INCOGNITO));
-    layout->StartRow(1, 0);
-    layout->AddView(go_incognito_button_);
-  }
-
   if (display_lock) {
-    if (!switches::IsMaterialDesignUserMenu()) {
-      layout->StartRow(1, 0);
-      layout->AddView(new views::Separator());
-    }
-
     lock_button_ = new BackgroundColorHoverButton(
         this, l10n_util::GetStringUTF16(IDS_PROFILES_PROFILE_SIGNOUT_BUTTON),
         gfx::CreateVectorIcon(kLockIcon, kIconSize, gfx::kChromeIconGrey));
     layout->StartRow(1, 0);
     layout->AddView(lock_button_);
-  } else if (switches::IsMaterialDesignUserMenu() && !is_guest) {
+  } else if (!is_guest) {
     int num_browsers = 0;
     for (auto* browser : *BrowserList::GetInstance()) {
       if (browser->profile()->GetOriginalProfile() ==
           browser_->profile()->GetOriginalProfile())
         num_browsers++;
     }
     if (num_browsers > 1) {
       close_all_windows_button_ = new BackgroundColorHoverButton(
           this,
           l10n_util::GetStringUTF16(IDS_PROFILES_CLOSE_ALL_WINDOWS_BUTTON),
           gfx::CreateVectorIcon(kCloseAllIcon, kIconSize,
                                 gfx::kChromeIconGrey));
       layout->StartRow(1, 0);
       layout->AddView(close_all_windows_button_);
     }
   }
 
-  if (switches::IsMaterialDesignUserMenu())
-    layout->StartRowWithPadding(1, 0, 0, views::kRelatedControlVerticalSpacing);
+  layout->StartRowWithPadding(1, 0, 0, views::kRelatedControlVerticalSpacing);
   return view;
 }
 
 views::View* ProfileChooserView::CreateSupervisedUserDisclaimerView() {
   views::View* view = new views::View();
-  int horizontal_margin = switches::IsMaterialDesignUserMenu() ?
-      kMaterialMenuEdgeMargin : views::kButtonHEdgeMarginNew;
-  views::GridLayout* layout = CreateSingleColumnLayout(
-      view, GetFixedMenuWidth() - 2 * horizontal_margin);
-  if (switches::IsMaterialDesignUserMenu()) {
-    layout->SetInsets(0, horizontal_margin,
-                      kMaterialMenuEdgeMargin, horizontal_margin);
-  } else {
-    layout->SetInsets(
-        views::kRelatedControlVerticalSpacing, horizontal_margin,
-        views::kRelatedControlVerticalSpacing, horizontal_margin);
-  }
+  int horizontal_margin = kMenuEdgeMargin;
+  views::GridLayout* layout =
+      CreateSingleColumnLayout(view, kFixedMenuWidth - 2 * horizontal_margin);
+  layout->SetInsets(0, horizontal_margin, kMenuEdgeMargin, horizontal_margin);
 
   views::Label* disclaimer = new views::Label(
       avatar_menu_->GetSupervisedUserInformation());
   disclaimer->SetMultiLine(true);
   disclaimer->SetAllowCharacterBreak(true);
   disclaimer->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   disclaimer->SetFontList(rb->GetFontList(ui::ResourceBundle::SmallFont));
   layout->StartRow(1, 0);
   layout->AddView(disclaimer);
 
   return view;
 }
 
 views::View* ProfileChooserView::CreateCurrentProfileAccountsView(
     const AvatarMenu::Item& avatar_item) {
   DCHECK(avatar_item.signed_in);
   views::View* view = new views::View();
   view->set_background(views::Background::CreateSolidBackground(
       profiles::kAvatarBubbleAccountsBackgroundColor));
-  views::GridLayout* layout =
-      CreateSingleColumnLayout(view, GetFixedMenuWidth());
+  views::GridLayout* layout = CreateSingleColumnLayout(view, kFixedMenuWidth);
 
   Profile* profile = browser_->profile();
   std::string primary_account =
       SigninManagerFactory::GetForProfile(profile)->GetAuthenticatedAccountId();
   DCHECK(!primary_account.empty());
   std::vector<std::string>accounts =
       profiles::GetSecondaryAccountsForProfile(profile, primary_account);
 
   // Get state of authentication error, if any.
   std::string error_account_id = GetAuthErrorAccountId(profile);
 
   // The primary account should always be listed first.
   // TODO(rogerta): we still need to further differentiate the primary account
   // from the others in the UI, so more work is likely required here:
   // crbug.com/311124.
   CreateAccountButton(layout, primary_account, true,
-                      error_account_id == primary_account, GetFixedMenuWidth());
+                      error_account_id == primary_account, kFixedMenuWidth);
   for (size_t i = 0; i < accounts.size(); ++i)
     CreateAccountButton(layout, accounts[i], false,
-                        error_account_id == accounts[i], GetFixedMenuWidth());
+                        error_account_id == accounts[i], kFixedMenuWidth);
 
   if (!profile->IsSupervised()) {
     layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
 
     add_account_link_ = CreateLink(l10n_util::GetStringFUTF16(
         IDS_PROFILES_PROFILE_ADD_ACCOUNT_BUTTON, avatar_item.name), this);
     add_account_link_->SetBorder(
         views::CreateEmptyBorder(0, views::kButtonVEdgeMarginNew,
                                  views::kRelatedControlVerticalSpacing, 0));
     layout->StartRow(1, 0);
@@ skipping 286 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;
 }