Simplify some old avatar menu button code.

chrome/browser/ui/views/frame/opaque_browser_frame_view_layout_unittest.cc

 // Copyright 2013 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/frame/opaque_browser_frame_view_layout.h"
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/layout_constants.h"
-#include "chrome/browser/ui/views/profiles/avatar_menu_button.h"
+#include "chrome/browser/ui/views/profiles/profile_indicator_icon.h"
 #include "chrome/browser/ui/views/tab_icon_view.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/label.h"
@@ skipping 10 matching lines @@
 const int kMaximizeButtonWidth = 25;
 const int kCloseButtonWidth = 43;
 const int kMaximizedExtraCloseWidth = OBFVL::kFrameBorderThickness -
     views::NonClientFrameView::kFrameShadowThickness;
 const int kCaptionButtonsWidth =
     kMinimizeButtonWidth + kMaximizeButtonWidth + kCloseButtonWidth;
 const int kCaptionButtonHeight = 18;
 
 class TestLayoutDelegate : public OpaqueBrowserFrameViewLayoutDelegate {
  public:
-  TestLayoutDelegate()
-      : show_avatar_(false),
-        show_caption_buttons_(true),
-        maximized_(false) {
-  }
+  TestLayoutDelegate() : show_caption_buttons_(true), maximized_(false) {}
   ~TestLayoutDelegate() override {}
 
   void set_window_title(const base::string16& title) { window_title_ = title; }
-  void set_show_avatar(bool show_avatar) { show_avatar_ = show_avatar; }
   void set_show_caption_buttons(bool show_caption_buttons) {
     show_caption_buttons_ = show_caption_buttons;
   }
   void set_maximized(bool maximized) { maximized_ = maximized; }
 
   // OpaqueBrowserFrameViewLayoutDelegate:
   bool ShouldShowWindowIcon() const override { return !window_title_.empty(); }
   bool ShouldShowWindowTitle() const override { return !window_title_.empty(); }
   base::string16 GetWindowTitle() const override { return window_title_; }
   int GetIconSize() const override { return 17; }
   gfx::Size GetBrowserViewMinimumSize() const override {
     return gfx::Size(168, 64);
   }
   bool ShouldShowCaptionButtons() const override {
     return show_caption_buttons_;
   }
-  bool ShouldShowAvatar() const override { return show_avatar_; }
   bool IsRegularOrGuestSession() const override { return true; }
   gfx::ImageSkia GetOTRAvatarIcon() const override {
     return gfx::ImageSkia(gfx::ImageSkiaRep(gfx::Size(40, 29), 1.0f));
   }
   bool IsMaximized() const override { return maximized_; }
   bool IsMinimized() const override { return false; }
   bool IsFullscreen() const override { return false; }
   bool IsTabStripVisible() const override { return window_title_.empty(); }
   int GetTabStripHeight() const override {
     return IsTabStripVisible() ? Tab::GetMinimumInactiveSize().height() : 0;
   }
   bool IsToolbarVisible() const override { return true; }
   gfx::Size GetTabstripPreferredSize() const override {
     return IsTabStripVisible() ? gfx::Size(78, 29) : gfx::Size();
   }
   int GetToolbarLeadingCornerClientWidth() const override { return 0; }
 
  private:
   base::string16 window_title_;
-  bool show_avatar_;
   bool show_caption_buttons_;
   bool maximized_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayoutDelegate);
 };
 
 }  // namespace
 
 class OpaqueBrowserFrameViewLayoutTest : public views::ViewsTestBase {
  public:
@@ skipping 61 matching lines @@
     window_title_ = new views::Label(delegate_->GetWindowTitle());
     window_title_->SetVisible(delegate_->ShouldShowWindowTitle());
     window_title_->SetEnabledColor(SK_ColorWHITE);
     window_title_->SetSubpixelRenderingEnabled(false);
     window_title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
     window_title_->set_id(VIEW_ID_WINDOW_TITLE);
     root_view_->AddChildView(window_title_);
   }
 
   void AddNewAvatarButton() {
-    new_avatar_button_ =
-        new views::MenuButton(base::string16(), nullptr, false);
-    new_avatar_button_->set_id(VIEW_ID_NEW_AVATAR_BUTTON);
-    root_view_->AddChildView(new_avatar_button_);
-    delegate_->set_show_avatar(true);
+    avatar_button_ = new views::MenuButton(base::string16(), nullptr, false);
+    avatar_button_->set_id(VIEW_ID_AVATAR_BUTTON);
+    root_view_->AddChildView(avatar_button_);
   }
 
   int CaptionY() const {
     return delegate_->IsMaximized() ?
         0 : views::NonClientFrameView::kFrameShadowThickness;
   }
 
   int CaptionLeft() const {
     return kWindowWidth -
         (delegate_->IsMaximized() ? kMaximizedExtraCloseWidth
@@ skipping 49 matching lines @@
     EXPECT_EQ(kMinimizeButtonWidth, minimize_button_->width());
     EXPECT_EQ(visible_button->height(), minimize_button_->height());
     EXPECT_TRUE(minimize_button_->visible());
     EXPECT_FALSE(hidden_button->visible());
   }
 
   void ExpectTabStripAndMinimumSize(bool caption_buttons_on_left) {
     int caption_buttons_width = kCaptionButtonsWidth;
     bool show_caption_buttons = delegate_->ShouldShowCaptionButtons();
     bool maximized = delegate_->IsMaximized() || !show_caption_buttons;
-    if (delegate_->ShouldShowAvatar()) {
-      caption_buttons_width += new_avatar_button_->GetPreferredSize().width() +
+    if (avatar_button_) {
+      caption_buttons_width +=
+          avatar_button_->GetPreferredSize().width() +
           (maximized ? OBFVL::kCaptionSpacing
                      : -GetLayoutSize(NEW_TAB_BUTTON).width());
     }
     int tabstrip_x = GetLayoutInsets(AVATAR_ICON).right();
     if (show_caption_buttons && caption_buttons_on_left) {
       int right_of_close =
           maximized ? kMaximizedExtraCloseWidth : OBFVL::kFrameBorderThickness;
       tabstrip_x += caption_buttons_width + right_of_close;
     } else if (!maximized) {
       tabstrip_x += kNonClientBorderThickness;
@@ skipping 64 matching lines @@
         (delegate_->IsMaximized() ? 0 : OBFVL::kFrameBorderThickness) +
         OBFVL::kIconLeftSpacing + icon_size + OBFVL::kIconTitleSpacing;
     gfx::Rect title_bounds(window_title_->bounds());
     EXPECT_EQ(title_x, title_bounds.x());
     EXPECT_EQ(IconAndTitleY(), title_bounds.y());
     EXPECT_EQ(CaptionLeft() - title_x, title_bounds.width());
     EXPECT_EQ(icon_size, title_bounds.height());
   }
 
   void ExpectAvatar() {
-    int avatar_width = new_avatar_button_->GetPreferredSize().width();
-    gfx::Rect avatar_bounds(new_avatar_button_->bounds());
+    int avatar_width = avatar_button_->GetPreferredSize().width();
+    gfx::Rect avatar_bounds(avatar_button_->bounds());
     EXPECT_EQ(CaptionLeft() - avatar_width, avatar_bounds.x());
     EXPECT_EQ(CaptionY(), avatar_bounds.y());
     EXPECT_EQ(avatar_width, avatar_bounds.width());
     EXPECT_EQ(kCaptionButtonHeight, avatar_bounds.height());
   }
 
-  views::Widget* widget_;
-  views::View* root_view_;
-  OBFVL* layout_manager_;
+  views::Widget* widget_ = nullptr;
+  views::View* root_view_ = nullptr;
+  OBFVL* layout_manager_ = nullptr;
   std::unique_ptr<TestLayoutDelegate> delegate_;
 
   // Widgets:
-  views::ImageButton* minimize_button_;
-  views::ImageButton* maximize_button_;
-  views::ImageButton* restore_button_;
-  views::ImageButton* close_button_;
+  views::ImageButton* minimize_button_ = nullptr;
+  views::ImageButton* maximize_button_ = nullptr;
+  views::ImageButton* restore_button_ = nullptr;
+  views::ImageButton* close_button_ = nullptr;
 
-  TabIconView* tab_icon_view_;
-  views::Label* window_title_;
+  TabIconView* tab_icon_view_ = nullptr;
+  views::Label* window_title_ = nullptr;
 
-  AvatarMenuButton* menu_button_;
-  views::MenuButton* new_avatar_button_;
+  AvatarMenuButton* menu_button_ = nullptr;
+  views::MenuButton* avatar_button_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(OpaqueBrowserFrameViewLayoutTest);
 };
 
 TEST_F(OpaqueBrowserFrameViewLayoutTest, BasicWindow) {
   // Tests the layout of a default chrome window with no avatars, no window
   // titles, and a tabstrip.
 
   for (int i = 0; i < 2; ++i) {
     root_view_->Layout();
@@ skipping 72 matching lines @@
 
   for (int i = 0; i < 2; ++i) {
     root_view_->Layout();
     SCOPED_TRACE(i == 0 ? "Window is restored" : "Window is maximized");
     ExpectCaptionButtons(false, 0);
     ExpectTabStripAndMinimumSize(false);
     ExpectAvatar();
     delegate_->set_maximized(true);
   }
 }