1// Copyright (c) 2011 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/constrained_window_views.h"
6
7#include <algorithm>
8
9#include "chrome/app/chrome_command_ids.h"
10#include "chrome/browser/profiles/profile.h"
11#include "chrome/browser/ui/toolbar/toolbar_model.h"
12#include "chrome/browser/ui/views/frame/browser_view.h"
13#include "chrome/browser/ui/window_sizer.h"
14#include "chrome/common/chrome_constants.h"
15#include "content/browser/tab_contents/tab_contents.h"
16#include "content/browser/tab_contents/tab_contents_view.h"
17#include "content/common/notification_service.h"
18#include "grit/app_resources.h"
19#include "grit/chromium_strings.h"
20#include "grit/generated_resources.h"
21#include "grit/theme_resources.h"
22#include "net/base/net_util.h"
23#include "ui/base/resource/resource_bundle.h"
24#include "ui/gfx/canvas.h"
25#include "ui/gfx/font.h"
26#include "ui/gfx/path.h"
27#include "ui/gfx/rect.h"
28#include "views/controls/button/image_button.h"
29#include "views/focus/focus_manager.h"
30#include "views/window/client_view.h"
31#include "views/window/native_window.h"
32#include "views/window/non_client_view.h"
33#include "views/window/window_resources.h"
34#include "views/window/window_shape.h"
35#include "views/window/window.h"
36
37#if defined(OS_WIN)
38#include "views/widget/widget_win.h"
39#include "views/window/window_win.h"
40#endif
41
42using base::TimeDelta;
43
44namespace views {
45class ClientView;
46}
47
48// An enumeration of bitmap resources used by this window.
49enum {
50  FRAME_PART_BITMAP_FIRST = 0,  // Must be first.
51
52  // Window Frame Border.
53  FRAME_BOTTOM_EDGE,
54  FRAME_BOTTOM_LEFT_CORNER,
55  FRAME_BOTTOM_RIGHT_CORNER,
56  FRAME_LEFT_EDGE,
57  FRAME_RIGHT_EDGE,
58  FRAME_TOP_EDGE,
59  FRAME_TOP_LEFT_CORNER,
60  FRAME_TOP_RIGHT_CORNER,
61
62  FRAME_PART_BITMAP_COUNT  // Must be last.
63};
64
65static const int kXPFramePartIDs[] = {
66    0,
67    IDR_WINDOW_BOTTOM_CENTER, IDR_WINDOW_BOTTOM_LEFT_CORNER,
68    IDR_WINDOW_BOTTOM_RIGHT_CORNER, IDR_WINDOW_LEFT_SIDE,
69    IDR_WINDOW_RIGHT_SIDE, IDR_WINDOW_TOP_CENTER,
70    IDR_WINDOW_TOP_LEFT_CORNER, IDR_WINDOW_TOP_RIGHT_CORNER,
71    0 };
72static const int kVistaFramePartIDs[] = {
73    0,
74    IDR_CONSTRAINED_BOTTOM_CENTER_V, IDR_CONSTRAINED_BOTTOM_LEFT_CORNER_V,
75    IDR_CONSTRAINED_BOTTOM_RIGHT_CORNER_V, IDR_CONSTRAINED_LEFT_SIDE_V,
76    IDR_CONSTRAINED_RIGHT_SIDE_V, IDR_CONSTRAINED_TOP_CENTER_V,
77    IDR_CONSTRAINED_TOP_LEFT_CORNER_V, IDR_CONSTRAINED_TOP_RIGHT_CORNER_V,
78    0 };
79
80class XPWindowResources : public views::WindowResources {
81 public:
82  XPWindowResources() {
83    InitClass();
84  }
85  virtual ~XPWindowResources() {}
86
87  virtual SkBitmap* GetPartBitmap(views::FramePartBitmap part_id) const {
88    return bitmaps_[part_id];
89  }
90
91 private:
92  static void InitClass() {
93    static bool initialized = false;
94    if (!initialized) {
95      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
96      for (int i = 0; i < FRAME_PART_BITMAP_COUNT; ++i) {
97        int id = kXPFramePartIDs[i];
98        if (id != 0)
99          bitmaps_[i] = rb.GetBitmapNamed(id);
100      }
101      initialized = true;
102    }
103  }
104
105  static SkBitmap* bitmaps_[FRAME_PART_BITMAP_COUNT];
106
107  DISALLOW_COPY_AND_ASSIGN(XPWindowResources);
108};
109
110class VistaWindowResources : public views::WindowResources {
111 public:
112  VistaWindowResources() {
113    InitClass();
114  }
115  virtual ~VistaWindowResources() {}
116
117  virtual SkBitmap* GetPartBitmap(views::FramePartBitmap part_id) const {
118    return bitmaps_[part_id];
119  }
120
121 private:
122  static void InitClass() {
123    static bool initialized = false;
124    if (!initialized) {
125      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
126      for (int i = 0; i < FRAME_PART_BITMAP_COUNT; ++i) {
127        int id = kVistaFramePartIDs[i];
128        if (id != 0)
129          bitmaps_[i] = rb.GetBitmapNamed(id);
130      }
131      initialized = true;
132    }
133  }
134
135  static SkBitmap* bitmaps_[FRAME_PART_BITMAP_COUNT];
136
137  DISALLOW_COPY_AND_ASSIGN(VistaWindowResources);
138};
139
140SkBitmap* XPWindowResources::bitmaps_[];
141SkBitmap* VistaWindowResources::bitmaps_[];
142
143////////////////////////////////////////////////////////////////////////////////
144// ConstrainedWindowFrameView
145
146class ConstrainedWindowFrameView
147    : public views::NonClientFrameView,
148      public views::ButtonListener {
149 public:
150  explicit ConstrainedWindowFrameView(ConstrainedWindowViews* container);
151  virtual ~ConstrainedWindowFrameView();
152
153  void UpdateWindowTitle();
154
155  // Overridden from views::NonClientFrameView:
156  virtual gfx::Rect GetBoundsForClientView() const OVERRIDE;
157  virtual bool AlwaysUseCustomFrame() const OVERRIDE;
158  virtual gfx::Rect GetWindowBoundsForClientBounds(
159      const gfx::Rect& client_bounds) const OVERRIDE;
160  virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE;
161  virtual void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask)
162      OVERRIDE;
163  virtual void EnableClose(bool enable) OVERRIDE;
164  virtual void ResetWindowControls() OVERRIDE {}
165  virtual void UpdateWindowIcon() OVERRIDE {}
166
167  // Overridden from views::View:
168  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
169  virtual void Layout() OVERRIDE;
170  virtual void OnThemeChanged() OVERRIDE;
171
172  // Overridden from views::ButtonListener:
173  virtual void ButtonPressed(views::Button* sender, const views::Event& event)
174      OVERRIDE;
175
176 private:
177  // Returns the thickness of the entire nonclient left, right, and bottom
178  // borders, including both the window frame and any client edge.
179  int NonClientBorderThickness() const;
180
181  // Returns the height of the entire nonclient top border, including the window
182  // frame, any title area, and any connected client edge.
183  int NonClientTopBorderHeight() const;
184
185  // Returns the thickness of the nonclient portion of the 3D edge along the
186  // bottom of the titlebar.
187  int TitlebarBottomThickness() const;
188
189  // Returns what the size of the titlebar icon would be if there was one.
190  int IconSize() const;
191
192  // Returns what the titlebar icon's bounds would be if there was one.
193  gfx::Rect IconBounds() const;
194
195  // Paints different parts of the window to the incoming canvas.
196  void PaintFrameBorder(gfx::Canvas* canvas);
197  void PaintTitleBar(gfx::Canvas* canvas);
198  void PaintClientEdge(gfx::Canvas* canvas);
199
200  // Layout various sub-components of this view.
201  void LayoutWindowControls();
202  void LayoutTitleBar();
203
204  // Returns the bounds of the client area for the specified view size.
205  gfx::Rect CalculateClientAreaBounds(int width, int height) const;
206
207  SkColor GetTitleColor() const {
208    return container_->owner()->profile()->IsOffTheRecord()
209#if defined(OS_WIN)
210            || !views::WidgetWin::IsAeroGlassEnabled()
211#endif
212            ? SK_ColorWHITE : SK_ColorBLACK;
213  }
214
215  // Loads the appropriate set of WindowResources for the frame view.
216  void InitWindowResources();
217
218  ConstrainedWindowViews* container_;
219
220  scoped_ptr<views::WindowResources> resources_;
221
222  gfx::Rect title_bounds_;
223
224  views::ImageButton* close_button_;
225
226  // The bounds of the ClientView.
227  gfx::Rect client_view_bounds_;
228
229  static void InitClass();
230
231  // The font to be used to render the titlebar text.
232  static gfx::Font* title_font_;
233
234  DISALLOW_COPY_AND_ASSIGN(ConstrainedWindowFrameView);
235};
236
237gfx::Font* ConstrainedWindowFrameView::title_font_ = NULL;
238
239namespace {
240// The frame border is only visible in restored mode and is hardcoded to 4 px on
241// each side regardless of the system window border size.
242const int kFrameBorderThickness = 4;
243// Various edges of the frame border have a 1 px shadow along their edges; in a
244// few cases we shift elements based on this amount for visual appeal.
245const int kFrameShadowThickness = 1;
246// In the window corners, the resize areas don't actually expand bigger, but the
247// 16 px at the end of each edge triggers diagonal resizing.
248const int kResizeAreaCornerSize = 16;
249// The titlebar never shrinks too short to show the caption button plus some
250// padding below it.
251const int kCaptionButtonHeightWithPadding = 19;
252// The titlebar has a 2 px 3D edge along the top and bottom.
253const int kTitlebarTopAndBottomEdgeThickness = 2;
254// The icon would never shrink below 16 px on a side, if there was one.
255const int kIconMinimumSize = 16;
256// The title text starts 2 px from the right edge of the left frame border.
257const int kTitleLeftSpacing = 2;
258// There is a 5 px gap between the title text and the caption buttons.
259const int kTitleCaptionSpacing = 5;
260
261const SkColor kContentsBorderShadow = SkColorSetARGB(51, 0, 0, 0);
262}
263
264////////////////////////////////////////////////////////////////////////////////
265// ConstrainedWindowFrameView, public:
266
267ConstrainedWindowFrameView::ConstrainedWindowFrameView(
268    ConstrainedWindowViews* container)
269        : NonClientFrameView(),
270          container_(container),
271          close_button_(new views::ImageButton(this)) {
272  InitClass();
273  InitWindowResources();
274
275  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
276  close_button_->SetImage(views::CustomButton::BS_NORMAL,
277                          rb.GetBitmapNamed(IDR_CLOSE_SA));
278  close_button_->SetImage(views::CustomButton::BS_HOT,
279                          rb.GetBitmapNamed(IDR_CLOSE_SA_H));
280  close_button_->SetImage(views::CustomButton::BS_PUSHED,
281                          rb.GetBitmapNamed(IDR_CLOSE_SA_P));
282  close_button_->SetImageAlignment(views::ImageButton::ALIGN_CENTER,
283                                   views::ImageButton::ALIGN_MIDDLE);
284  AddChildView(close_button_);
285}
286
287ConstrainedWindowFrameView::~ConstrainedWindowFrameView() {
288}
289
290void ConstrainedWindowFrameView::UpdateWindowTitle() {
291  SchedulePaintInRect(title_bounds_);
292}
293
294////////////////////////////////////////////////////////////////////////////////
295// ConstrainedWindowFrameView, views::NonClientFrameView implementation:
296
297gfx::Rect ConstrainedWindowFrameView::GetBoundsForClientView() const {
298  return client_view_bounds_;
299}
300
301bool ConstrainedWindowFrameView::AlwaysUseCustomFrame() const {
302  // Constrained windows always use the custom frame - they just have a
303  // different set of bitmaps.
304  return true;
305}
306
307gfx::Rect ConstrainedWindowFrameView::GetWindowBoundsForClientBounds(
308    const gfx::Rect& client_bounds) const {
309  int top_height = NonClientTopBorderHeight();
310  int border_thickness = NonClientBorderThickness();
311  return gfx::Rect(std::max(0, client_bounds.x() - border_thickness),
312                   std::max(0, client_bounds.y() - top_height),
313                   client_bounds.width() + (2 * border_thickness),
314                   client_bounds.height() + top_height + border_thickness);
315}
316
317int ConstrainedWindowFrameView::NonClientHitTest(const gfx::Point& point) {
318  if (!bounds().Contains(point))
319    return HTNOWHERE;
320
321  int frame_component =
322      container_->GetWindow()->client_view()->NonClientHitTest(point);
323
324  // See if we're in the sysmenu region.  (We check the ClientView first to be
325  // consistent with OpaqueBrowserFrameView; it's not really necessary here.)
326  gfx::Rect sysmenu_rect(IconBounds());
327  sysmenu_rect.set_x(GetMirroredXForRect(sysmenu_rect));
328  if (sysmenu_rect.Contains(point))
329    return (frame_component == HTCLIENT) ? HTCLIENT : HTSYSMENU;
330
331  if (frame_component != HTNOWHERE)
332    return frame_component;
333
334  // Then see if the point is within any of the window controls.
335  if (close_button_->GetMirroredBounds().Contains(point))
336    return HTCLOSE;
337
338  int window_component = GetHTComponentForFrame(point, kFrameBorderThickness,
339      NonClientBorderThickness(), kResizeAreaCornerSize, kResizeAreaCornerSize,
340      container_->GetWindow()->window_delegate()->CanResize());
341  // Fall back to the caption if no other component matches.
342  return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
343}
344
345void ConstrainedWindowFrameView::GetWindowMask(const gfx::Size& size,
346                                               gfx::Path* window_mask) {
347  DCHECK(window_mask);
348  views::GetDefaultWindowMask(size, window_mask);
349}
350
351void ConstrainedWindowFrameView::EnableClose(bool enable) {
352  close_button_->SetEnabled(enable);
353}
354
355////////////////////////////////////////////////////////////////////////////////
356// ConstrainedWindowFrameView, views::View implementation:
357
358void ConstrainedWindowFrameView::OnPaint(gfx::Canvas* canvas) {
359  PaintFrameBorder(canvas);
360  PaintTitleBar(canvas);
361  PaintClientEdge(canvas);
362}
363
364void ConstrainedWindowFrameView::Layout() {
365  LayoutWindowControls();
366  LayoutTitleBar();
367  client_view_bounds_ = CalculateClientAreaBounds(width(), height());
368}
369
370void ConstrainedWindowFrameView::OnThemeChanged() {
371  InitWindowResources();
372}
373
374////////////////////////////////////////////////////////////////////////////////
375// ConstrainedWindowFrameView, views::ButtonListener implementation:
376
377void ConstrainedWindowFrameView::ButtonPressed(
378    views::Button* sender, const views::Event& event) {
379  if (sender == close_button_)
380    container_->CloseConstrainedWindow();
381}
382
383////////////////////////////////////////////////////////////////////////////////
384// ConstrainedWindowFrameView, private:
385
386int ConstrainedWindowFrameView::NonClientBorderThickness() const {
387  return kFrameBorderThickness + kClientEdgeThickness;
388}
389
390int ConstrainedWindowFrameView::NonClientTopBorderHeight() const {
391  return std::max(kFrameBorderThickness + IconSize(),
392                  kFrameShadowThickness + kCaptionButtonHeightWithPadding) +
393      TitlebarBottomThickness();
394}
395
396int ConstrainedWindowFrameView::TitlebarBottomThickness() const {
397  return kTitlebarTopAndBottomEdgeThickness + kClientEdgeThickness;
398}
399
400int ConstrainedWindowFrameView::IconSize() const {
401#if defined(OS_WIN)
402  // This metric scales up if either the titlebar height or the titlebar font
403  // size are increased.
404  return GetSystemMetrics(SM_CYSMICON);
405#else
406  return std::max(title_font_->height(), kIconMinimumSize);
407#endif
408}
409
410gfx::Rect ConstrainedWindowFrameView::IconBounds() const {
411  int size = IconSize();
412  // Our frame border has a different "3D look" than Windows'.  Theirs has a
413  // more complex gradient on the top that they push their icon/title below;
414  // then the maximized window cuts this off and the icon/title are centered
415  // in the remaining space.  Because the apparent shape of our border is
416  // simpler, using the same positioning makes things look slightly uncentered
417  // with restored windows, so instead of calculating the remaining space from
418  // below the frame border, we calculate from below the 3D edge.
419  int unavailable_px_at_top = kTitlebarTopAndBottomEdgeThickness;
420  // When the icon is shorter than the minimum space we reserve for the caption
421  // button, we vertically center it.  We want to bias rounding to put extra
422  // space above the icon, since the 3D edge + client edge below looks (to the
423  // eye) more like additional space than does the 3D edge above; hence the +1.
424  int y = unavailable_px_at_top + (NonClientTopBorderHeight() -
425      unavailable_px_at_top - size - TitlebarBottomThickness() + 1) / 2;
426  return gfx::Rect(kFrameBorderThickness + kTitleLeftSpacing, y, size, size);
427}
428
429void ConstrainedWindowFrameView::PaintFrameBorder(gfx::Canvas* canvas) {
430  SkBitmap* top_left_corner = resources_->GetPartBitmap(FRAME_TOP_LEFT_CORNER);
431  SkBitmap* top_right_corner =
432      resources_->GetPartBitmap(FRAME_TOP_RIGHT_CORNER);
433  SkBitmap* top_edge = resources_->GetPartBitmap(FRAME_TOP_EDGE);
434  SkBitmap* right_edge = resources_->GetPartBitmap(FRAME_RIGHT_EDGE);
435  SkBitmap* left_edge = resources_->GetPartBitmap(FRAME_LEFT_EDGE);
436  SkBitmap* bottom_left_corner =
437      resources_->GetPartBitmap(FRAME_BOTTOM_LEFT_CORNER);
438  SkBitmap* bottom_right_corner =
439      resources_->GetPartBitmap(FRAME_BOTTOM_RIGHT_CORNER);
440  SkBitmap* bottom_edge = resources_->GetPartBitmap(FRAME_BOTTOM_EDGE);
441
442  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
443  SkBitmap* theme_frame = rb.GetBitmapNamed(IDR_THEME_FRAME);
444  SkColor frame_color = ResourceBundle::frame_color;
445
446  // Fill with the frame color first so we have a constant background for
447  // areas not covered by the theme image.
448  canvas->FillRectInt(frame_color, 0, 0, width(), theme_frame->height());
449  // Now fill down the sides.
450  canvas->FillRectInt(frame_color, 0, theme_frame->height(), left_edge->width(),
451                      height() - theme_frame->height());
452  canvas->FillRectInt(frame_color, width() - right_edge->width(),
453                      theme_frame->height(), right_edge->width(),
454                      height() - theme_frame->height());
455  // Now fill the bottom area.
456  canvas->FillRectInt(frame_color,
457      left_edge->width(), height() - bottom_edge->height(),
458      width() - left_edge->width() - right_edge->width(),
459      bottom_edge->height());
460
461  // Draw the theme frame.
462  canvas->TileImageInt(*theme_frame, 0, 0, width(), theme_frame->height());
463
464  // Top.
465  canvas->DrawBitmapInt(*top_left_corner, 0, 0);
466  canvas->TileImageInt(*top_edge, top_left_corner->width(), 0,
467                       width() - top_right_corner->width(), top_edge->height());
468  canvas->DrawBitmapInt(*top_right_corner,
469                        width() - top_right_corner->width(), 0);
470
471  // Right.
472  canvas->TileImageInt(*right_edge, width() - right_edge->width(),
473      top_right_corner->height(), right_edge->width(),
474      height() - top_right_corner->height() - bottom_right_corner->height());
475
476  // Bottom.
477  canvas->DrawBitmapInt(*bottom_right_corner,
478                        width() - bottom_right_corner->width(),
479                        height() - bottom_right_corner->height());
480  canvas->TileImageInt(*bottom_edge, bottom_left_corner->width(),
481      height() - bottom_edge->height(),
482      width() - bottom_left_corner->width() - bottom_right_corner->width(),
483      bottom_edge->height());
484  canvas->DrawBitmapInt(*bottom_left_corner, 0,
485                        height() - bottom_left_corner->height());
486
487  // Left.
488  canvas->TileImageInt(*left_edge, 0, top_left_corner->height(),
489      left_edge->width(),
490      height() - top_left_corner->height() - bottom_left_corner->height());
491}
492
493void ConstrainedWindowFrameView::PaintTitleBar(gfx::Canvas* canvas) {
494  canvas->DrawStringInt(
495      container_->GetWindow()->window_delegate()->GetWindowTitle(),
496      *title_font_, GetTitleColor(), GetMirroredXForRect(title_bounds_),
497      title_bounds_.y(), title_bounds_.width(), title_bounds_.height());
498}
499
500void ConstrainedWindowFrameView::PaintClientEdge(gfx::Canvas* canvas) {
501  gfx::Rect client_edge_bounds(CalculateClientAreaBounds(width(), height()));
502  client_edge_bounds.Inset(-kClientEdgeThickness, -kClientEdgeThickness);
503  gfx::Rect frame_shadow_bounds(client_edge_bounds);
504  frame_shadow_bounds.Inset(-kFrameShadowThickness, -kFrameShadowThickness);
505
506  canvas->FillRectInt(kContentsBorderShadow, frame_shadow_bounds.x(),
507                      frame_shadow_bounds.y(), frame_shadow_bounds.width(),
508                      frame_shadow_bounds.height());
509
510  canvas->FillRectInt(ResourceBundle::toolbar_color, client_edge_bounds.x(),
511                      client_edge_bounds.y(), client_edge_bounds.width(),
512                      client_edge_bounds.height());
513}
514
515void ConstrainedWindowFrameView::LayoutWindowControls() {
516  gfx::Size close_button_size = close_button_->GetPreferredSize();
517  close_button_->SetBounds(
518      width() - kFrameBorderThickness - close_button_size.width(),
519      kFrameShadowThickness, close_button_size.width(),
520      close_button_size.height());
521}
522
523void ConstrainedWindowFrameView::LayoutTitleBar() {
524  // The window title is based on the calculated icon position, even though'
525  // there is no icon in constrained windows.
526  gfx::Rect icon_bounds(IconBounds());
527  int title_x = icon_bounds.x();
528  int title_height = title_font_->GetHeight();
529  // We bias the title position so that when the difference between the icon and
530  // title heights is odd, the extra pixel of the title is above the vertical
531  // midline rather than below.  This compensates for how the icon is already
532  // biased downwards (see IconBounds()) and helps prevent descenders on the
533  // title from overlapping the 3D edge at the bottom of the titlebar.
534  title_bounds_.SetRect(title_x,
535      icon_bounds.y() + ((icon_bounds.height() - title_height - 1) / 2),
536      std::max(0, close_button_->x() - kTitleCaptionSpacing - title_x),
537      title_height);
538}
539
540gfx::Rect ConstrainedWindowFrameView::CalculateClientAreaBounds(
541    int width,
542    int height) const {
543  int top_height = NonClientTopBorderHeight();
544  int border_thickness = NonClientBorderThickness();
545  return gfx::Rect(border_thickness, top_height,
546                   std::max(0, width - (2 * border_thickness)),
547                   std::max(0, height - top_height - border_thickness));
548}
549
550void ConstrainedWindowFrameView::InitWindowResources() {
551  resources_.reset(views::WidgetWin::IsAeroGlassEnabled() ?
552    static_cast<views::WindowResources*>(new VistaWindowResources) :
553    new XPWindowResources);
554}
555
556// static
557void ConstrainedWindowFrameView::InitClass() {
558  static bool initialized = false;
559  if (!initialized) {
560#if defined(OS_WIN)
561    title_font_ = new gfx::Font(views::WindowWin::GetWindowTitleFont());
562#endif
563    initialized = true;
564  }
565}
566
567////////////////////////////////////////////////////////////////////////////////
568// ConstrainedWindowViews, public:
569
570ConstrainedWindowViews::ConstrainedWindowViews(
571    TabContents* owner,
572    views::WindowDelegate* window_delegate)
573    : owner_(owner),
574      ALLOW_THIS_IN_INITIALIZER_LIST(native_constrained_window_(
575          NativeConstrainedWindow::CreateNativeConstrainedWindow(
576              this, window_delegate))) {
577  GetWindow()->non_client_view()->SetFrameView(CreateFrameViewForWindow());
578  native_constrained_window_->InitNativeConstrainedWindow(
579      owner->GetNativeView());
580}
581
582ConstrainedWindowViews::~ConstrainedWindowViews() {
583}
584
585views::Window* ConstrainedWindowViews::GetWindow() {
586  return native_constrained_window_->AsNativeWindow()->GetWindow();
587}
588
589////////////////////////////////////////////////////////////////////////////////
590// ConstrainedWindowViews, ConstrainedWindow implementation:
591
592void ConstrainedWindowViews::ShowConstrainedWindow() {
593  // We marked the view as hidden during construction.  Mark it as
594  // visible now so FocusManager will let us receive focus.
595  GetWindow()->non_client_view()->SetVisible(true);
596  if (owner_->delegate())
597    owner_->delegate()->WillShowConstrainedWindow(owner_);
598  GetWindow()->Activate();
599  FocusConstrainedWindow();
600}
601
602void ConstrainedWindowViews::CloseConstrainedWindow() {
603  // Broadcast to all observers of NOTIFY_CWINDOW_CLOSED.
604  // One example of such an observer is AutomationCWindowTracker in the
605  // automation component.
606  NotificationService::current()->Notify(NotificationType::CWINDOW_CLOSED,
607                                         Source<ConstrainedWindow>(this),
608                                         NotificationService::NoDetails());
609  GetWindow()->CloseWindow();
610}
611
612void ConstrainedWindowViews::FocusConstrainedWindow() {
613  if ((!owner_->delegate() ||
614       owner_->delegate()->ShouldFocusConstrainedWindow()) &&
615      GetWindow()->window_delegate() &&
616      GetWindow()->window_delegate()->GetInitiallyFocusedView()) {
617    GetWindow()->window_delegate()->GetInitiallyFocusedView()->RequestFocus();
618  }
619}
620
621////////////////////////////////////////////////////////////////////////////////
622// ConstrainedWindowViews, NativeConstrainedWindowDelegate implementation:
623
624void ConstrainedWindowViews::OnNativeConstrainedWindowDestroyed() {
625  // Tell our constraining TabContents that we've gone so it can update its
626  // list.
627  owner_->WillClose(this);
628}
629
630void ConstrainedWindowViews::OnNativeConstrainedWindowMouseActivate() {
631  GetWindow()->Activate();
632}
633
634views::NonClientFrameView* ConstrainedWindowViews::CreateFrameViewForWindow() {
635  return new ConstrainedWindowFrameView(this);
636}
637
638////////////////////////////////////////////////////////////////////////////////
639// ConstrainedWindow, public:
640
641// static
642ConstrainedWindow* ConstrainedWindow::CreateConstrainedDialog(
643    TabContents* parent,
644    views::WindowDelegate* window_delegate) {
645  return new ConstrainedWindowViews(parent, window_delegate);
646}
647