1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/ui/views/frame/opaque_browser_frame_view_layout.h"
6
7#include "base/basictypes.h"
8#include "base/command_line.h"
9#include "base/strings/utf_string_conversions.h"
10#include "chrome/browser/ui/views/profiles/avatar_label.h"
11#include "chrome/browser/ui/views/profiles/avatar_menu_button.h"
12#include "chrome/browser/ui/views/tab_icon_view.h"
13#include "chrome/browser/ui/views/tabs/tab.h"
14#include "chrome/common/chrome_switches.h"
15#include "components/signin/core/common/profile_management_switches.h"
16#include "ui/gfx/image/image_skia.h"
17#include "ui/gfx/image/image_skia_rep.h"
18#include "ui/gfx/text_constants.h"
19#include "ui/views/controls/button/image_button.h"
20#include "ui/views/controls/button/menu_button.h"
21#include "ui/views/controls/label.h"
22#include "ui/views/test/views_test_base.h"
23
24using views::Widget;
25
26namespace {
27
28const int kWidth = 500;
29
30class TestLayoutDelegate : public OpaqueBrowserFrameViewLayoutDelegate {
31 public:
32  enum WindowState {
33    STATE_NORMAL,
34    STATE_MAXIMIZED,
35    STATE_MINIMIZED,
36    STATE_FULLSCREEN
37  };
38
39  TestLayoutDelegate()
40      : show_avatar_(false),
41        show_caption_buttons_(true),
42        window_state_(STATE_NORMAL) {
43  }
44
45  virtual ~TestLayoutDelegate() {}
46
47  void SetWindowTitle(const base::string16& title) {
48    window_title_ = title;
49  }
50
51  void SetShouldShowAvatar(bool show_avatar) {
52    show_avatar_ = show_avatar;
53  }
54
55  void SetShouldShowCaptionButtons(bool show_caption_buttons) {
56    show_caption_buttons_ = show_caption_buttons;
57  }
58
59  void SetWindowState(WindowState state) {
60    window_state_ = state;
61  }
62
63  // OpaqueBrowserFrameViewLayoutDelegate overrides:
64
65  virtual bool ShouldShowWindowIcon() const OVERRIDE {
66    return !window_title_.empty();
67  }
68
69  virtual bool ShouldShowWindowTitle() const OVERRIDE {
70    return !window_title_.empty();
71  }
72
73  virtual base::string16 GetWindowTitle() const OVERRIDE {
74    return window_title_;
75  }
76
77  virtual int GetIconSize() const OVERRIDE {
78    // The value on linux_aura and non-aura windows.
79    return 17;
80  }
81
82  virtual bool ShouldLeaveOffsetNearTopBorder() const OVERRIDE {
83    return !IsMaximized();
84  }
85
86  virtual gfx::Size GetBrowserViewMinimumSize() const OVERRIDE {
87    // Taken from a calculation in BrowserViewLayout.
88    return gfx::Size(168, 64);
89  }
90
91  virtual bool ShouldShowCaptionButtons() const OVERRIDE {
92    return show_caption_buttons_;
93  }
94
95  virtual bool ShouldShowAvatar() const OVERRIDE {
96    return show_avatar_;
97  }
98
99  virtual bool IsRegularOrGuestSession() const OVERRIDE {
100    return true;
101  }
102
103  virtual gfx::ImageSkia GetOTRAvatarIcon() const OVERRIDE {
104    // The calculations depend on the size of the OTR resource, and chromeos
105    // uses a different sized image, so hard code the size of the current
106    // windows/linux one.
107    gfx::ImageSkiaRep rep(gfx::Size(40, 29), 1.0f);
108    gfx::ImageSkia image(rep);
109    return image;
110  }
111
112  virtual bool IsMaximized() const OVERRIDE {
113    return window_state_ == STATE_MAXIMIZED;
114  }
115
116  virtual bool IsMinimized() const OVERRIDE {
117    return window_state_ == STATE_MINIMIZED;
118  }
119
120  virtual bool IsFullscreen() const OVERRIDE {
121    return window_state_ == STATE_FULLSCREEN;
122  }
123
124  virtual bool IsTabStripVisible() const OVERRIDE {
125    return window_title_.empty();
126  }
127
128  virtual int GetTabStripHeight() const OVERRIDE {
129    return IsTabStripVisible() ? Tab::GetMinimumUnselectedSize().height() : 0;
130  }
131
132  virtual gfx::Size GetTabstripPreferredSize() const OVERRIDE {
133    // Measured from Tabstrip::GetPreferredSize().
134    return IsTabStripVisible() ? gfx::Size(78, 29) : gfx::Size(0, 0);
135  }
136
137 private:
138  base::string16 window_title_;
139  bool show_avatar_;
140  bool show_caption_buttons_;
141  WindowState window_state_;
142
143  DISALLOW_COPY_AND_ASSIGN(TestLayoutDelegate);
144};
145
146}  // namespace
147
148class OpaqueBrowserFrameViewLayoutTest : public views::ViewsTestBase {
149 public:
150  OpaqueBrowserFrameViewLayoutTest() {}
151  virtual ~OpaqueBrowserFrameViewLayoutTest() {}
152
153  virtual void SetUp() OVERRIDE {
154    views::ViewsTestBase::SetUp();
155
156    delegate_.reset(new TestLayoutDelegate);
157    layout_manager_ = new OpaqueBrowserFrameViewLayout(delegate_.get());
158    layout_manager_->set_extra_caption_y(0);
159    layout_manager_->set_window_caption_spacing(0);
160    widget_ = new Widget;
161    widget_->Init(CreateParams(Widget::InitParams::TYPE_POPUP));
162    root_view_ = widget_->GetRootView();
163    root_view_->SetSize(gfx::Size(kWidth, kWidth));
164    root_view_->SetLayoutManager(layout_manager_);
165
166    // Add the caption buttons. We use fake images because we're modeling the
167    // Windows assets here, while the linux version uses differently sized
168    // assets.
169    //
170    // TODO(erg): In a follow up patch, separate these sizes out into virtual
171    // accessors so we can test both the windows and linux behaviours once we
172    // start modifying the code.
173    minimize_button_ = InitWindowCaptionButton(
174        VIEW_ID_MINIMIZE_BUTTON, gfx::Size(26, 18));
175    maximize_button_ = InitWindowCaptionButton(
176        VIEW_ID_MAXIMIZE_BUTTON, gfx::Size(25, 18));
177    restore_button_ = InitWindowCaptionButton(
178        VIEW_ID_RESTORE_BUTTON, gfx::Size(25, 18));
179    close_button_ = InitWindowCaptionButton(
180        VIEW_ID_CLOSE_BUTTON, gfx::Size(43, 18));
181  }
182
183  virtual void TearDown() OVERRIDE {
184    widget_->CloseNow();
185
186    views::ViewsTestBase::TearDown();
187  }
188
189 protected:
190  views::ImageButton* InitWindowCaptionButton(ViewID view_id,
191                                              const gfx::Size& size) {
192    views::ImageButton* button = new views::ImageButton(NULL);
193    gfx::ImageSkiaRep rep(size, 1.0f);
194    gfx::ImageSkia image(rep);
195    button->SetImage(views::CustomButton::STATE_NORMAL, &image);
196    button->set_id(view_id);
197    root_view_->AddChildView(button);
198    return button;
199  }
200
201  void AddWindowTitleIcons() {
202    tab_icon_view_ = new TabIconView(NULL, NULL);
203    tab_icon_view_->set_is_light(true);
204    tab_icon_view_->set_id(VIEW_ID_WINDOW_ICON);
205    root_view_->AddChildView(tab_icon_view_);
206
207    window_title_ = new views::Label(delegate_->GetWindowTitle());
208    window_title_->SetVisible(delegate_->ShouldShowWindowTitle());
209    window_title_->SetEnabledColor(SK_ColorWHITE);
210    window_title_->SetSubpixelRenderingEnabled(false);
211    window_title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
212    window_title_->set_id(VIEW_ID_WINDOW_TITLE);
213    root_view_->AddChildView(window_title_);
214  }
215
216  void AddAvatarButton() {
217    // Disable the New Avatar Menu.
218    switches::DisableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
219
220    menu_button_ = new AvatarMenuButton(NULL, false);
221    menu_button_->set_id(VIEW_ID_AVATAR_BUTTON);
222    delegate_->SetShouldShowAvatar(true);
223    root_view_->AddChildView(menu_button_);
224  }
225
226  void AddAvatarLabel() {
227    avatar_label_ = new AvatarLabel(NULL);
228    avatar_label_->set_id(VIEW_ID_AVATAR_LABEL);
229    root_view_->AddChildView(avatar_label_);
230
231    // The avatar label should only be used together with the avatar button.
232    AddAvatarButton();
233  }
234
235  void AddNewAvatarButton() {
236    // Enable the New Avatar Menu.
237    switches::EnableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
238
239    new_avatar_button_ =
240        new views::MenuButton(NULL, base::string16(), NULL, false);
241    new_avatar_button_->set_id(VIEW_ID_NEW_AVATAR_BUTTON);
242    root_view_->AddChildView(new_avatar_button_);
243  }
244
245  void ExpectBasicWindowBounds() {
246    EXPECT_EQ("428,1 25x18", maximize_button_->bounds().ToString());
247    EXPECT_EQ("402,1 26x18", minimize_button_->bounds().ToString());
248    EXPECT_EQ("0,0 0x0", restore_button_->bounds().ToString());
249    EXPECT_EQ("453,1 43x18", close_button_->bounds().ToString());
250  }
251
252  Widget* widget_;
253  views::View* root_view_;
254  OpaqueBrowserFrameViewLayout* layout_manager_;
255  scoped_ptr<TestLayoutDelegate> delegate_;
256
257  // Widgets:
258  views::ImageButton* minimize_button_;
259  views::ImageButton* maximize_button_;
260  views::ImageButton* restore_button_;
261  views::ImageButton* close_button_;
262
263  TabIconView* tab_icon_view_;
264  views::Label* window_title_;
265
266  AvatarLabel* avatar_label_;
267  AvatarMenuButton* menu_button_;
268  views::MenuButton* new_avatar_button_;
269
270  DISALLOW_COPY_AND_ASSIGN(OpaqueBrowserFrameViewLayoutTest);
271};
272
273TEST_F(OpaqueBrowserFrameViewLayoutTest, BasicWindow) {
274  // Tests the layout of a default chrome window with no avatars, no window
275  // titles, and a tabstrip.
276  root_view_->Layout();
277
278  ExpectBasicWindowBounds();
279
280  // After some visual inspection, it really does look like the tabstrip is
281  // initally positioned out of our view.
282  EXPECT_EQ("-1,13 398x29",
283            layout_manager_->GetBoundsForTabStrip(
284                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
285  EXPECT_EQ("261x73", layout_manager_->GetMinimumSize(kWidth).ToString());
286
287  // A normal window with no window icon still produces icon bounds for
288  // Windows, which has a hidden icon that a user can double click on to close
289  // the window.
290  EXPECT_EQ("6,4 17x17", layout_manager_->IconBounds().ToString());
291}
292
293TEST_F(OpaqueBrowserFrameViewLayoutTest, BasicWindowMaximized) {
294  // Tests the layout of a default chrome window with no avatars, no window
295  // titles, and a tabstrip, but maximized this time.
296  delegate_->SetWindowState(TestLayoutDelegate::STATE_MAXIMIZED);
297  root_view_->Layout();
298
299  // Note how the bounds start at the exact top of the window while maximized
300  // while they start 1 pixel below when unmaximized.
301  EXPECT_EQ("0,0 0x0", maximize_button_->bounds().ToString());
302  EXPECT_EQ("403,0 26x18", minimize_button_->bounds().ToString());
303  EXPECT_EQ("429,0 25x18", restore_button_->bounds().ToString());
304  EXPECT_EQ("454,0 46x18", close_button_->bounds().ToString());
305
306  EXPECT_EQ("-5,-3 392x29",
307            layout_manager_->GetBoundsForTabStrip(
308                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
309  EXPECT_EQ("262x61", layout_manager_->GetMinimumSize(kWidth).ToString());
310
311  // In the maximized case, OpaqueBrowserFrameView::NonClientHitTest() uses
312  // this rect, extended to the top left corner of the window.
313  EXPECT_EQ("2,0 17x17", layout_manager_->IconBounds().ToString());
314}
315
316TEST_F(OpaqueBrowserFrameViewLayoutTest, MaximizedWithYOffset) {
317  // Tests the layout of a basic chrome window with the caption buttons slightly
318  // offset from the top of the screen (as they are on Linux).
319  layout_manager_->set_extra_caption_y(2);
320  delegate_->SetWindowState(TestLayoutDelegate::STATE_MAXIMIZED);
321  root_view_->Layout();
322
323  // Note how the bounds start at the exact top of the window, DESPITE the
324  // caption Y offset of 2. This ensures that we obey Fitts' Law (the buttons
325  // are clickable on the top edge of the screen). However, the buttons are 2
326  // pixels taller, so the images appear to be offset by 2 pixels.
327  EXPECT_EQ("0,0 0x0", maximize_button_->bounds().ToString());
328  EXPECT_EQ("403,0 26x20", minimize_button_->bounds().ToString());
329  EXPECT_EQ("429,0 25x20", restore_button_->bounds().ToString());
330  EXPECT_EQ("454,0 46x20", close_button_->bounds().ToString());
331
332  EXPECT_EQ("-5,-3 392x29",
333            layout_manager_->GetBoundsForTabStrip(
334                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
335  EXPECT_EQ("262x61", layout_manager_->GetMinimumSize(kWidth).ToString());
336
337  // In the maximized case, OpaqueBrowserFrameView::NonClientHitTest() uses
338  // this rect, extended to the top left corner of the window.
339  EXPECT_EQ("2,0 17x17", layout_manager_->IconBounds().ToString());
340}
341
342TEST_F(OpaqueBrowserFrameViewLayoutTest, WindowButtonsOnLeft) {
343  // Tests the layout of a chrome window with caption buttons on the left.
344  std::vector<views::FrameButton> leading_buttons;
345  std::vector<views::FrameButton> trailing_buttons;
346  leading_buttons.push_back(views::FRAME_BUTTON_CLOSE);
347  leading_buttons.push_back(views::FRAME_BUTTON_MINIMIZE);
348  leading_buttons.push_back(views::FRAME_BUTTON_MAXIMIZE);
349  layout_manager_->SetButtonOrdering(leading_buttons, trailing_buttons);
350  root_view_->Layout();
351
352  EXPECT_EQ("73,1 25x18", maximize_button_->bounds().ToString());
353  EXPECT_EQ("47,1 26x18", minimize_button_->bounds().ToString());
354  EXPECT_EQ("0,0 0x0", restore_button_->bounds().ToString());
355  EXPECT_EQ("4,1 43x18", close_button_->bounds().ToString());
356
357  EXPECT_EQ("93,13 398x29",
358            layout_manager_->GetBoundsForTabStrip(
359                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
360  EXPECT_EQ("261x73", layout_manager_->GetMinimumSize(kWidth).ToString());
361
362  // If the buttons are on the left, there should be no hidden icon for the user
363  // to double click.
364  EXPECT_EQ("0,0 0x0", layout_manager_->IconBounds().ToString());
365}
366
367TEST_F(OpaqueBrowserFrameViewLayoutTest, WithoutCaptionButtons) {
368  // Tests the layout of a default chrome window with no caption buttons (which
369  // should force the tab strip to be condensed).
370  delegate_->SetShouldShowCaptionButtons(false);
371  root_view_->Layout();
372
373  EXPECT_EQ("0,0 0x0", maximize_button_->bounds().ToString());
374  EXPECT_EQ("0,0 0x0", minimize_button_->bounds().ToString());
375  EXPECT_EQ("0,0 0x0", restore_button_->bounds().ToString());
376  EXPECT_EQ("0,0 0x0", close_button_->bounds().ToString());
377
378  EXPECT_EQ("-5,-3 500x29",
379            layout_manager_->GetBoundsForTabStrip(
380                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
381  EXPECT_EQ("251x61", layout_manager_->GetMinimumSize(kWidth).ToString());
382
383  // A normal window with no window icon still produces icon bounds for
384  // Windows, which has a hidden icon that a user can double click on to close
385  // the window.
386  EXPECT_EQ("2,0 17x17", layout_manager_->IconBounds().ToString());
387}
388
389TEST_F(OpaqueBrowserFrameViewLayoutTest, MaximizedWithoutCaptionButtons) {
390  // Tests the layout of a maximized chrome window with no caption buttons.
391  delegate_->SetWindowState(TestLayoutDelegate::STATE_MAXIMIZED);
392  delegate_->SetShouldShowCaptionButtons(false);
393  root_view_->Layout();
394
395  EXPECT_EQ("0,0 0x0", maximize_button_->bounds().ToString());
396  EXPECT_EQ("0,0 0x0", minimize_button_->bounds().ToString());
397  EXPECT_EQ("0,0 0x0", restore_button_->bounds().ToString());
398  EXPECT_EQ("0,0 0x0", close_button_->bounds().ToString());
399
400  EXPECT_EQ("-5,-3 500x29",
401            layout_manager_->GetBoundsForTabStrip(
402                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
403  EXPECT_EQ("251x61", layout_manager_->GetMinimumSize(kWidth).ToString());
404
405  // In the maximized case, OpaqueBrowserFrameView::NonClientHitTest() uses
406  // this rect, extended to the top left corner of the window.
407  EXPECT_EQ("2,0 17x17", layout_manager_->IconBounds().ToString());
408}
409
410TEST_F(OpaqueBrowserFrameViewLayoutTest, WithWindowTitleAndIcon) {
411  // Tests the layout of pop up windows.
412  delegate_->SetWindowTitle(base::ASCIIToUTF16("Window Title"));
413  AddWindowTitleIcons();
414  root_view_->Layout();
415
416  // We should have the right hand side should match the BasicWindow case.
417  ExpectBasicWindowBounds();
418
419  // Check the location of the tab icon and window title.
420  EXPECT_EQ("6,3 17x17", tab_icon_view_->bounds().ToString());
421  EXPECT_EQ("27,3 370x17", window_title_->bounds().ToString());
422}
423
424TEST_F(OpaqueBrowserFrameViewLayoutTest, WindowWithAvatar) {
425  // Tests a normal tabstrip window with an avatar icon.
426  AddAvatarButton();
427  root_view_->Layout();
428
429  ExpectBasicWindowBounds();
430
431  // Check the location of the avatar
432  EXPECT_EQ("7,11 40x29", menu_button_->bounds().ToString());
433  EXPECT_EQ("45,13 352x29",
434            layout_manager_->GetBoundsForTabStrip(
435                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
436  EXPECT_EQ("261x73", layout_manager_->GetMinimumSize(kWidth).ToString());
437}
438
439TEST_F(OpaqueBrowserFrameViewLayoutTest, WindowWithAvatarWithButtonsOnLeft) {
440  // Tests the layout of a chrome window with an avatar icon and caption buttons
441  // on the left. The avatar icon should therefore be on the right.
442  // AddAvatarLabel() also adds the avatar button.
443  AddAvatarLabel();
444  std::vector<views::FrameButton> leading_buttons;
445  std::vector<views::FrameButton> trailing_buttons;
446  leading_buttons.push_back(views::FRAME_BUTTON_CLOSE);
447  leading_buttons.push_back(views::FRAME_BUTTON_MINIMIZE);
448  leading_buttons.push_back(views::FRAME_BUTTON_MAXIMIZE);
449  layout_manager_->SetButtonOrdering(leading_buttons, trailing_buttons);
450  root_view_->Layout();
451
452  EXPECT_EQ("73,1 25x18", maximize_button_->bounds().ToString());
453  EXPECT_EQ("47,1 26x18", minimize_button_->bounds().ToString());
454  EXPECT_EQ("0,0 0x0", restore_button_->bounds().ToString());
455  EXPECT_EQ("4,1 43x18", close_button_->bounds().ToString());
456
457  // Check the location of the avatar
458  EXPECT_EQ("454,11 40x29", menu_button_->bounds().ToString());
459
460  // Check the tab strip bounds.
461  gfx::Rect tab_strip_bounds = layout_manager_->GetBoundsForTabStrip(
462      delegate_->GetTabstripPreferredSize(), kWidth);
463  EXPECT_GT(tab_strip_bounds.x(), maximize_button_->bounds().x());
464  EXPECT_GT(maximize_button_->bounds().right(), tab_strip_bounds.x());
465  EXPECT_EQ(13, tab_strip_bounds.y());
466  EXPECT_EQ(29, tab_strip_bounds.height());
467  EXPECT_GT(avatar_label_->bounds().x(), tab_strip_bounds.right());
468  EXPECT_EQ("261x73", layout_manager_->GetMinimumSize(kWidth).ToString());
469
470  // Check the relative location of the avatar label to the avatar. The right
471  // end of the avatar label should be slightly to the right of the right end of
472  // the avatar icon.
473  EXPECT_GT(avatar_label_->bounds().right(), menu_button_->bounds().right());
474  EXPECT_GT(menu_button_->bounds().x(), avatar_label_->bounds().x());
475  EXPECT_GT(menu_button_->bounds().bottom(),
476            avatar_label_->bounds().bottom());
477  EXPECT_GT(avatar_label_->bounds().y(), menu_button_->bounds().y());
478
479  // This means that the menu will pop out facing the left (if it were to face
480  // the right, it would go outside the window frame and be clipped).
481  EXPECT_TRUE(menu_button_->button_on_right());
482
483  // If the buttons are on the left, there should be no hidden icon for the user
484  // to double click.
485  EXPECT_EQ("0,0 0x0", layout_manager_->IconBounds().ToString());
486}
487
488TEST_F(OpaqueBrowserFrameViewLayoutTest,
489       WindowWithAvatarWithoutCaptionButtonsOnLeft) {
490  // Tests the layout of a chrome window with an avatar icon and no caption
491  // buttons. However, the caption buttons *would* be on the left if they
492  // weren't hidden, and therefore, the avatar icon should be on the right.
493  // The lack of caption buttons should force the tab strip to be condensed.
494  AddAvatarButton();
495  std::vector<views::FrameButton> leading_buttons;
496  std::vector<views::FrameButton> trailing_buttons;
497  leading_buttons.push_back(views::FRAME_BUTTON_CLOSE);
498  leading_buttons.push_back(views::FRAME_BUTTON_MINIMIZE);
499  leading_buttons.push_back(views::FRAME_BUTTON_MAXIMIZE);
500  layout_manager_->SetButtonOrdering(leading_buttons, trailing_buttons);
501  delegate_->SetShouldShowCaptionButtons(false);
502  root_view_->Layout();
503
504  EXPECT_EQ("0,0 0x0", maximize_button_->bounds().ToString());
505  EXPECT_EQ("0,0 0x0", minimize_button_->bounds().ToString());
506  EXPECT_EQ("0,0 0x0", restore_button_->bounds().ToString());
507  EXPECT_EQ("0,0 0x0", close_button_->bounds().ToString());
508
509  // Check the location of the avatar
510  EXPECT_EQ("458,0 40x24", menu_button_->bounds().ToString());
511  EXPECT_EQ("-5,-3 458x29",
512            layout_manager_->GetBoundsForTabStrip(
513                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
514  EXPECT_EQ("251x61", layout_manager_->GetMinimumSize(kWidth).ToString());
515
516  // A normal window with no window icon still produces icon bounds for
517  // Windows, which has a hidden icon that a user can double click on to close
518  // the window.
519  EXPECT_EQ("2,0 17x17", layout_manager_->IconBounds().ToString());
520}
521
522TEST_F(OpaqueBrowserFrameViewLayoutTest, WindowWithNewAvatar) {
523  // Tests a normal tabstrip window with the new style avatar icon.
524  AddNewAvatarButton();
525  root_view_->Layout();
526
527  ExpectBasicWindowBounds();
528
529  // Check the location of the avatar button.
530  EXPECT_EQ("385,1 12x18", new_avatar_button_->bounds().ToString());
531  // The new tab button is 39px wide and slides completely under the new
532  // avatar button, thus increasing the tabstrip by that amount.
533  EXPECT_EQ("-1,13 420x29",
534            layout_manager_->GetBoundsForTabStrip(
535                delegate_->GetTabstripPreferredSize(), kWidth).ToString());
536  EXPECT_EQ("261x73", layout_manager_->GetMinimumSize(kWidth).ToString());
537}
538
539TEST_F(OpaqueBrowserFrameViewLayoutTest, WindowWithAvatarLabelAndButtonOnLeft) {
540  AddAvatarLabel();
541  root_view_->Layout();
542
543  ExpectBasicWindowBounds();
544
545  // Check the location of the avatar label relative to the avatar button if
546  // both are displayed on the left side.
547  // The label height and width depends on the font size and the text displayed.
548  // This may possibly change, so we don't test it here.
549  EXPECT_EQ(menu_button_->bounds().x() - 2, avatar_label_->bounds().x());
550  EXPECT_EQ(
551      menu_button_->bounds().bottom() - 3 - avatar_label_->bounds().height(),
552      avatar_label_->bounds().y());
553}
554