1 // Copyright (c) 2012 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 "ash/frame/custom_frame_view_ash.h"
6
7 #include <algorithm>
8 #include <vector>
9
10 #include "ash/ash_switches.h"
11 #include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
12 #include "ash/frame/default_header_painter.h"
13 #include "ash/frame/frame_border_hit_test_controller.h"
14 #include "ash/frame/frame_util.h"
15 #include "ash/frame/header_painter.h"
16 #include "ash/session/session_state_delegate.h"
17 #include "ash/shell.h"
18 #include "ash/shell_observer.h"
19 #include "ash/wm/immersive_fullscreen_controller.h"
20 #include "ash/wm/window_state.h"
21 #include "ash/wm/window_state_delegate.h"
22 #include "ash/wm/window_state_observer.h"
23 #include "base/command_line.h"
24 #include "ui/aura/client/aura_constants.h"
25 #include "ui/aura/window.h"
26 #include "ui/aura/window_observer.h"
27 #include "ui/gfx/canvas.h"
28 #include "ui/gfx/image/image.h"
29 #include "ui/gfx/rect.h"
30 #include "ui/gfx/rect_conversions.h"
31 #include "ui/gfx/size.h"
32 #include "ui/views/controls/image_view.h"
33 #include "ui/views/view.h"
34 #include "ui/views/view_targeter.h"
35 #include "ui/views/widget/widget.h"
36 #include "ui/views/widget/widget_delegate.h"
37
38 namespace {
39
40 ///////////////////////////////////////////////////////////////////////////////
41 // CustomFrameViewAshWindowStateDelegate
42
43 // Handles a user's fullscreen request (Shift+F4/F4). Puts the window into
44 // immersive fullscreen if immersive fullscreen is enabled for non-browser
45 // windows.
46 class CustomFrameViewAshWindowStateDelegate
47 : public ash::wm::WindowStateDelegate,
48 public ash::wm::WindowStateObserver,
49 public aura::WindowObserver {
50 public:
CustomFrameViewAshWindowStateDelegate(ash::wm::WindowState * window_state,ash::CustomFrameViewAsh * custom_frame_view)51 CustomFrameViewAshWindowStateDelegate(
52 ash::wm::WindowState* window_state,
53 ash::CustomFrameViewAsh* custom_frame_view)
54 : window_state_(NULL) {
55 immersive_fullscreen_controller_.reset(
56 new ash::ImmersiveFullscreenController);
57 custom_frame_view->InitImmersiveFullscreenControllerForView(
58 immersive_fullscreen_controller_.get());
59
60 // Add a window state observer to exit fullscreen properly in case
61 // fullscreen is exited without going through
62 // WindowState::ToggleFullscreen(). This is the case when exiting
63 // immersive fullscreen via the "Restore" window control.
64 // TODO(pkotwicz): This is a hack. Remove ASAP. http://crbug.com/319048
65 window_state_ = window_state;
66 window_state_->AddObserver(this);
67 window_state_->window()->AddObserver(this);
68 }
~CustomFrameViewAshWindowStateDelegate()69 virtual ~CustomFrameViewAshWindowStateDelegate() {
70 if (window_state_) {
71 window_state_->RemoveObserver(this);
72 window_state_->window()->RemoveObserver(this);
73 }
74 }
75 private:
76 // Overridden from ash::wm::WindowStateDelegate:
ToggleFullscreen(ash::wm::WindowState * window_state)77 virtual bool ToggleFullscreen(ash::wm::WindowState* window_state) OVERRIDE {
78 bool enter_fullscreen = !window_state->IsFullscreen();
79 if (enter_fullscreen) {
80 window_state->window()->SetProperty(aura::client::kShowStateKey,
81 ui::SHOW_STATE_FULLSCREEN);
82 } else {
83 window_state->Restore();
84 }
85 if (immersive_fullscreen_controller_) {
86 immersive_fullscreen_controller_->SetEnabled(
87 ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
88 enter_fullscreen);
89 }
90 return true;
91 }
92 // Overridden from aura::WindowObserver:
OnWindowDestroying(aura::Window * window)93 virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
94 window_state_->RemoveObserver(this);
95 window_state_->window()->RemoveObserver(this);
96 window_state_ = NULL;
97 }
98 // Overridden from ash::wm::WindowStateObserver:
OnPostWindowStateTypeChange(ash::wm::WindowState * window_state,ash::wm::WindowStateType old_type)99 virtual void OnPostWindowStateTypeChange(
100 ash::wm::WindowState* window_state,
101 ash::wm::WindowStateType old_type) OVERRIDE {
102 if (!window_state->IsFullscreen() &&
103 !window_state->IsMinimized() &&
104 immersive_fullscreen_controller_.get() &&
105 immersive_fullscreen_controller_->IsEnabled()) {
106 immersive_fullscreen_controller_->SetEnabled(
107 ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
108 false);
109 }
110 }
111
112 ash::wm::WindowState* window_state_;
113 scoped_ptr<ash::ImmersiveFullscreenController>
114 immersive_fullscreen_controller_;
115
116 DISALLOW_COPY_AND_ASSIGN(CustomFrameViewAshWindowStateDelegate);
117 };
118
119 } // namespace
120
121 namespace ash {
122
123 ///////////////////////////////////////////////////////////////////////////////
124 // CustomFrameViewAsh::HeaderView
125
126 // View which paints the header. It slides off and on screen in immersive
127 // fullscreen.
128 class CustomFrameViewAsh::HeaderView
129 : public views::View,
130 public ImmersiveFullscreenController::Delegate,
131 public ShellObserver {
132 public:
133 // |frame| is the widget that the caption buttons act on.
134 explicit HeaderView(views::Widget* frame);
135 virtual ~HeaderView();
136
137 // Schedules a repaint for the entire title.
138 void SchedulePaintForTitle();
139
140 // Tells the window controls to reset themselves to the normal state.
141 void ResetWindowControls();
142
143 // Returns the amount of the view's pixels which should be on screen.
144 int GetPreferredOnScreenHeight() const;
145
146 // Returns the view's preferred height.
147 int GetPreferredHeight() const;
148
149 // Returns the view's minimum width.
150 int GetMinimumWidth() const;
151
152 void UpdateAvatarIcon();
153
154 void SizeConstraintsChanged();
155
156 // views::View:
157 virtual void Layout() OVERRIDE;
158 virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
159 virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE;
160
161 // ShellObserver:
162 virtual void OnMaximizeModeStarted() OVERRIDE;
163 virtual void OnMaximizeModeEnded() OVERRIDE;
164
caption_button_container()165 FrameCaptionButtonContainerView* caption_button_container() {
166 return caption_button_container_;
167 }
168
avatar_icon() const169 views::View* avatar_icon() const {
170 return avatar_icon_;
171 }
172
173 private:
174 // ImmersiveFullscreenController::Delegate:
175 virtual void OnImmersiveRevealStarted() OVERRIDE;
176 virtual void OnImmersiveRevealEnded() OVERRIDE;
177 virtual void OnImmersiveFullscreenExited() OVERRIDE;
178 virtual void SetVisibleFraction(double visible_fraction) OVERRIDE;
179 virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() const OVERRIDE;
180
181 // The widget that the caption buttons act on.
182 views::Widget* frame_;
183
184 // Helper for painting the header.
185 scoped_ptr<DefaultHeaderPainter> header_painter_;
186
187 views::ImageView* avatar_icon_;
188
189 // View which contains the window caption buttons.
190 FrameCaptionButtonContainerView* caption_button_container_;
191
192 // The fraction of the header's height which is visible while in fullscreen.
193 // This value is meaningless when not in fullscreen.
194 double fullscreen_visible_fraction_;
195
196 DISALLOW_COPY_AND_ASSIGN(HeaderView);
197 };
198
HeaderView(views::Widget * frame)199 CustomFrameViewAsh::HeaderView::HeaderView(views::Widget* frame)
200 : frame_(frame),
201 header_painter_(new ash::DefaultHeaderPainter),
202 avatar_icon_(NULL),
203 caption_button_container_(NULL),
204 fullscreen_visible_fraction_(0) {
205 FrameCaptionButtonContainerView::MinimizeAllowed minimize_allowed =
206 frame_->widget_delegate()->CanMinimize() ?
207 FrameCaptionButtonContainerView::MINIMIZE_ALLOWED :
208 FrameCaptionButtonContainerView::MINIMIZE_DISALLOWED;
209 caption_button_container_ = new FrameCaptionButtonContainerView(frame_,
210 minimize_allowed);
211 caption_button_container_->UpdateSizeButtonVisibility();
212 AddChildView(caption_button_container_);
213
214 header_painter_->Init(frame_, this, caption_button_container_);
215 UpdateAvatarIcon();
216
217 Shell::GetInstance()->AddShellObserver(this);
218 }
219
~HeaderView()220 CustomFrameViewAsh::HeaderView::~HeaderView() {
221 Shell::GetInstance()->RemoveShellObserver(this);
222 }
223
SchedulePaintForTitle()224 void CustomFrameViewAsh::HeaderView::SchedulePaintForTitle() {
225 header_painter_->SchedulePaintForTitle();
226 }
227
ResetWindowControls()228 void CustomFrameViewAsh::HeaderView::ResetWindowControls() {
229 caption_button_container_->ResetWindowControls();
230 }
231
GetPreferredOnScreenHeight() const232 int CustomFrameViewAsh::HeaderView::GetPreferredOnScreenHeight() const {
233 if (frame_->IsFullscreen()) {
234 return static_cast<int>(
235 GetPreferredHeight() * fullscreen_visible_fraction_);
236 }
237 return GetPreferredHeight();
238 }
239
GetPreferredHeight() const240 int CustomFrameViewAsh::HeaderView::GetPreferredHeight() const {
241 return header_painter_->GetHeaderHeightForPainting();
242 }
243
GetMinimumWidth() const244 int CustomFrameViewAsh::HeaderView::GetMinimumWidth() const {
245 return header_painter_->GetMinimumHeaderWidth();
246 }
247
UpdateAvatarIcon()248 void CustomFrameViewAsh::HeaderView::UpdateAvatarIcon() {
249 SessionStateDelegate* delegate =
250 Shell::GetInstance()->session_state_delegate();
251 aura::Window* window = frame_->GetNativeView();
252 bool show = delegate->ShouldShowAvatar(window);
253 if (!show) {
254 if (!avatar_icon_)
255 return;
256 delete avatar_icon_;
257 avatar_icon_ = NULL;
258 } else {
259 gfx::ImageSkia image = GetAvatarImageForContext(
260 delegate->GetBrowserContextForWindow(window)).AsImageSkia();
261 DCHECK(!image.isNull());
262 DCHECK_EQ(image.width(), image.height());
263 if (!avatar_icon_) {
264 avatar_icon_ = new views::ImageView();
265 AddChildView(avatar_icon_);
266 }
267 avatar_icon_->SetImage(image);
268 }
269 header_painter_->UpdateLeftHeaderView(avatar_icon_);
270 Layout();
271 }
272
SizeConstraintsChanged()273 void CustomFrameViewAsh::HeaderView::SizeConstraintsChanged() {
274 caption_button_container_->ResetWindowControls();
275 caption_button_container_->UpdateSizeButtonVisibility();
276 Layout();
277 }
278
279 ///////////////////////////////////////////////////////////////////////////////
280 // CustomFrameViewAsh::HeaderView, views::View overrides:
281
Layout()282 void CustomFrameViewAsh::HeaderView::Layout() {
283 header_painter_->LayoutHeader();
284 }
285
OnPaint(gfx::Canvas * canvas)286 void CustomFrameViewAsh::HeaderView::OnPaint(gfx::Canvas* canvas) {
287 bool paint_as_active =
288 frame_->non_client_view()->frame_view()->ShouldPaintAsActive();
289 caption_button_container_->SetPaintAsActive(paint_as_active);
290
291 HeaderPainter::Mode header_mode = paint_as_active ?
292 HeaderPainter::MODE_ACTIVE : HeaderPainter::MODE_INACTIVE;
293 header_painter_->PaintHeader(canvas, header_mode);
294 }
295
296 void CustomFrameViewAsh::HeaderView::
ChildPreferredSizeChanged(views::View * child)297 ChildPreferredSizeChanged(views::View* child) {
298 // FrameCaptionButtonContainerView animates the visibility changes in
299 // UpdateSizeButtonVisibility(false). Due to this a new size is not available
300 // until the completion of the animation. Layout in response to the preferred
301 // size changes.
302 if (child != caption_button_container_)
303 return;
304 parent()->Layout();
305 }
306
307 ///////////////////////////////////////////////////////////////////////////////
308 // CustomFrameViewAsh::HeaderView, ShellObserver overrides:
309
OnMaximizeModeStarted()310 void CustomFrameViewAsh::HeaderView::OnMaximizeModeStarted() {
311 caption_button_container_->UpdateSizeButtonVisibility();
312 parent()->Layout();
313 }
314
OnMaximizeModeEnded()315 void CustomFrameViewAsh::HeaderView::OnMaximizeModeEnded() {
316 caption_button_container_->UpdateSizeButtonVisibility();
317 parent()->Layout();
318 }
319
320 ///////////////////////////////////////////////////////////////////////////////
321 // CustomFrameViewAsh::HeaderView,
322 // ImmersiveFullscreenController::Delegate overrides:
323
OnImmersiveRevealStarted()324 void CustomFrameViewAsh::HeaderView::OnImmersiveRevealStarted() {
325 fullscreen_visible_fraction_ = 0;
326 SetPaintToLayer(true);
327 SetFillsBoundsOpaquely(false);
328 parent()->Layout();
329 }
330
OnImmersiveRevealEnded()331 void CustomFrameViewAsh::HeaderView::OnImmersiveRevealEnded() {
332 fullscreen_visible_fraction_ = 0;
333 SetPaintToLayer(false);
334 parent()->Layout();
335 }
336
OnImmersiveFullscreenExited()337 void CustomFrameViewAsh::HeaderView::OnImmersiveFullscreenExited() {
338 fullscreen_visible_fraction_ = 0;
339 SetPaintToLayer(false);
340 parent()->Layout();
341 }
342
SetVisibleFraction(double visible_fraction)343 void CustomFrameViewAsh::HeaderView::SetVisibleFraction(
344 double visible_fraction) {
345 if (fullscreen_visible_fraction_ != visible_fraction) {
346 fullscreen_visible_fraction_ = visible_fraction;
347 parent()->Layout();
348 }
349 }
350
351 std::vector<gfx::Rect>
GetVisibleBoundsInScreen() const352 CustomFrameViewAsh::HeaderView::GetVisibleBoundsInScreen() const {
353 // TODO(pkotwicz): Implement views::View::ConvertRectToScreen().
354 gfx::Rect visible_bounds(GetVisibleBounds());
355 gfx::Point visible_origin_in_screen(visible_bounds.origin());
356 views::View::ConvertPointToScreen(this, &visible_origin_in_screen);
357 std::vector<gfx::Rect> bounds_in_screen;
358 bounds_in_screen.push_back(
359 gfx::Rect(visible_origin_in_screen, visible_bounds.size()));
360 return bounds_in_screen;
361 }
362
363 ///////////////////////////////////////////////////////////////////////////////
364 // CustomFrameViewAsh::OverlayView
365
366 // View which takes up the entire widget and contains the HeaderView. HeaderView
367 // is a child of OverlayView to avoid creating a larger texture than necessary
368 // when painting the HeaderView to its own layer.
369 class CustomFrameViewAsh::OverlayView : public views::View,
370 public views::ViewTargeterDelegate {
371 public:
372 explicit OverlayView(HeaderView* header_view);
373 virtual ~OverlayView();
374
375 // views::View:
376 virtual void Layout() OVERRIDE;
377
378 private:
379 // views::ViewTargeterDelegate:
380 virtual bool DoesIntersectRect(const views::View* target,
381 const gfx::Rect& rect) const OVERRIDE;
382
383 HeaderView* header_view_;
384
385 DISALLOW_COPY_AND_ASSIGN(OverlayView);
386 };
387
OverlayView(HeaderView * header_view)388 CustomFrameViewAsh::OverlayView::OverlayView(HeaderView* header_view)
389 : header_view_(header_view) {
390 AddChildView(header_view);
391 SetEventTargeter(
392 scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
393 }
394
~OverlayView()395 CustomFrameViewAsh::OverlayView::~OverlayView() {
396 }
397
398 ///////////////////////////////////////////////////////////////////////////////
399 // CustomFrameViewAsh::OverlayView, views::View overrides:
400
Layout()401 void CustomFrameViewAsh::OverlayView::Layout() {
402 // Layout |header_view_| because layout affects the result of
403 // GetPreferredOnScreenHeight().
404 header_view_->Layout();
405
406 int onscreen_height = header_view_->GetPreferredOnScreenHeight();
407 if (onscreen_height == 0) {
408 header_view_->SetVisible(false);
409 } else {
410 int height = header_view_->GetPreferredHeight();
411 header_view_->SetBounds(0, onscreen_height - height, width(), height);
412 header_view_->SetVisible(true);
413 }
414 }
415
416 ///////////////////////////////////////////////////////////////////////////////
417 // CustomFrameViewAsh::OverlayView, views::ViewTargeterDelegate overrides:
418
DoesIntersectRect(const views::View * target,const gfx::Rect & rect) const419 bool CustomFrameViewAsh::OverlayView::DoesIntersectRect(
420 const views::View* target,
421 const gfx::Rect& rect) const {
422 CHECK_EQ(target, this);
423 // Grab events in the header view. Return false for other events so that they
424 // can be handled by the client view.
425 return header_view_->HitTestRect(rect);
426 }
427
428 ////////////////////////////////////////////////////////////////////////////////
429 // CustomFrameViewAsh, public:
430
431 // static
432 const char CustomFrameViewAsh::kViewClassName[] = "CustomFrameViewAsh";
433
CustomFrameViewAsh(views::Widget * frame)434 CustomFrameViewAsh::CustomFrameViewAsh(views::Widget* frame)
435 : frame_(frame),
436 header_view_(new HeaderView(frame)),
437 frame_border_hit_test_controller_(
438 new FrameBorderHitTestController(frame_)) {
439 // |header_view_| is set as the non client view's overlay view so that it can
440 // overlay the web contents in immersive fullscreen.
441 frame->non_client_view()->SetOverlayView(new OverlayView(header_view_));
442
443 // A delegate for a more complex way of fullscreening the window may already
444 // be set. This is the case for packaged apps.
445 wm::WindowState* window_state = wm::GetWindowState(frame->GetNativeWindow());
446 if (!window_state->HasDelegate()) {
447 window_state->SetDelegate(scoped_ptr<wm::WindowStateDelegate>(
448 new CustomFrameViewAshWindowStateDelegate(
449 window_state, this)));
450 }
451 }
452
~CustomFrameViewAsh()453 CustomFrameViewAsh::~CustomFrameViewAsh() {
454 }
455
InitImmersiveFullscreenControllerForView(ImmersiveFullscreenController * immersive_fullscreen_controller)456 void CustomFrameViewAsh::InitImmersiveFullscreenControllerForView(
457 ImmersiveFullscreenController* immersive_fullscreen_controller) {
458 immersive_fullscreen_controller->Init(header_view_, frame_, header_view_);
459 }
460
461 ////////////////////////////////////////////////////////////////////////////////
462 // CustomFrameViewAsh, views::NonClientFrameView overrides:
463
GetBoundsForClientView() const464 gfx::Rect CustomFrameViewAsh::GetBoundsForClientView() const {
465 gfx::Rect client_bounds = bounds();
466 client_bounds.Inset(0, NonClientTopBorderHeight(), 0, 0);
467 return client_bounds;
468 }
469
GetWindowBoundsForClientBounds(const gfx::Rect & client_bounds) const470 gfx::Rect CustomFrameViewAsh::GetWindowBoundsForClientBounds(
471 const gfx::Rect& client_bounds) const {
472 gfx::Rect window_bounds = client_bounds;
473 window_bounds.Inset(0, -NonClientTopBorderHeight(), 0, 0);
474 return window_bounds;
475 }
476
NonClientHitTest(const gfx::Point & point)477 int CustomFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
478 return FrameBorderHitTestController::NonClientHitTest(this,
479 header_view_->caption_button_container(), point);
480 }
481
GetWindowMask(const gfx::Size & size,gfx::Path * window_mask)482 void CustomFrameViewAsh::GetWindowMask(const gfx::Size& size,
483 gfx::Path* window_mask) {
484 // No window masks in Aura.
485 }
486
ResetWindowControls()487 void CustomFrameViewAsh::ResetWindowControls() {
488 header_view_->ResetWindowControls();
489 }
490
UpdateWindowIcon()491 void CustomFrameViewAsh::UpdateWindowIcon() {
492 }
493
UpdateWindowTitle()494 void CustomFrameViewAsh::UpdateWindowTitle() {
495 header_view_->SchedulePaintForTitle();
496 }
497
SizeConstraintsChanged()498 void CustomFrameViewAsh::SizeConstraintsChanged() {
499 header_view_->SizeConstraintsChanged();
500 }
501
502 ////////////////////////////////////////////////////////////////////////////////
503 // CustomFrameViewAsh, views::View overrides:
504
GetPreferredSize() const505 gfx::Size CustomFrameViewAsh::GetPreferredSize() const {
506 gfx::Size pref = frame_->client_view()->GetPreferredSize();
507 gfx::Rect bounds(0, 0, pref.width(), pref.height());
508 return frame_->non_client_view()->GetWindowBoundsForClientBounds(
509 bounds).size();
510 }
511
GetClassName() const512 const char* CustomFrameViewAsh::GetClassName() const {
513 return kViewClassName;
514 }
515
GetMinimumSize() const516 gfx::Size CustomFrameViewAsh::GetMinimumSize() const {
517 gfx::Size min_client_view_size(frame_->client_view()->GetMinimumSize());
518 return gfx::Size(
519 std::max(header_view_->GetMinimumWidth(), min_client_view_size.width()),
520 NonClientTopBorderHeight() + min_client_view_size.height());
521 }
522
GetMaximumSize() const523 gfx::Size CustomFrameViewAsh::GetMaximumSize() const {
524 gfx::Size max_client_size(frame_->client_view()->GetMaximumSize());
525 int width = 0;
526 int height = 0;
527
528 if (max_client_size.width() > 0)
529 width = std::max(header_view_->GetMinimumWidth(), max_client_size.width());
530 if (max_client_size.height() > 0)
531 height = NonClientTopBorderHeight() + max_client_size.height();
532
533 return gfx::Size(width, height);
534 }
535
SchedulePaintInRect(const gfx::Rect & r)536 void CustomFrameViewAsh::SchedulePaintInRect(const gfx::Rect& r) {
537 // We may end up here before |header_view_| has been added to the Widget.
538 if (header_view_->GetWidget()) {
539 // The HeaderView is not a child of CustomFrameViewAsh. Redirect the paint
540 // to HeaderView instead.
541 gfx::RectF to_paint(r);
542 views::View::ConvertRectToTarget(this, header_view_, &to_paint);
543 header_view_->SchedulePaintInRect(gfx::ToEnclosingRect(to_paint));
544 } else {
545 views::NonClientFrameView::SchedulePaintInRect(r);
546 }
547 }
548
VisibilityChanged(views::View * starting_from,bool is_visible)549 void CustomFrameViewAsh::VisibilityChanged(views::View* starting_from,
550 bool is_visible) {
551 if (is_visible)
552 header_view_->UpdateAvatarIcon();
553 }
554
555 ////////////////////////////////////////////////////////////////////////////////
556 // CustomFrameViewAsh, views::ViewTargeterDelegate overrides:
557
GetHeaderView()558 views::View* CustomFrameViewAsh::GetHeaderView() {
559 return header_view_;
560 }
561
GetAvatarIconViewForTest() const562 const views::View* CustomFrameViewAsh::GetAvatarIconViewForTest() const {
563 return header_view_->avatar_icon();
564 }
565
566 ////////////////////////////////////////////////////////////////////////////////
567 // CustomFrameViewAsh, private:
568
569 // views::NonClientFrameView:
DoesIntersectRect(const views::View * target,const gfx::Rect & rect) const570 bool CustomFrameViewAsh::DoesIntersectRect(const views::View* target,
571 const gfx::Rect& rect) const {
572 CHECK_EQ(target, this);
573 // NonClientView hit tests the NonClientFrameView first instead of going in
574 // z-order. Return false so that events get to the OverlayView.
575 return false;
576 }
577
578 FrameCaptionButtonContainerView* CustomFrameViewAsh::
GetFrameCaptionButtonContainerViewForTest()579 GetFrameCaptionButtonContainerViewForTest() {
580 return header_view_->caption_button_container();
581 }
582
NonClientTopBorderHeight() const583 int CustomFrameViewAsh::NonClientTopBorderHeight() const {
584 return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
585 }
586
587 } // namespace ash
588