Re-land:

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

 // Copyright (c) 2011 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/app_panel_browser_frame_view.h"
 
 #include "base/compiler_specific.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/ui/views/frame/browser_frame.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
@@ skipping 128 matching lines @@
   return gfx::Rect(std::max(0, client_bounds.x() - border_thickness),
                    std::max(0, client_bounds.y() - top_height),
                    client_bounds.width() + (2 * border_thickness),
                    client_bounds.height() + top_height + border_thickness);
 }
 
 int AppPanelBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
   if (!bounds().Contains(point))
     return HTNOWHERE;
 
-  int frame_component =
-      frame_->GetWindow()->client_view()->NonClientHitTest(point);
+  int frame_component = frame_->client_view()->NonClientHitTest(point);
 
   // See if we're in the sysmenu region.  (We check the ClientView first to be
   // consistent with OpaqueBrowserFrameView; it's not really necessary here.)
   gfx::Rect sysmenu_rect(IconBounds());
   // In maximized mode we extend the rect to the screen corner to take advantage
   // of Fitts' Law.
-  if (frame_->GetWindow()->IsMaximized())
+  if (frame_->IsMaximized())
     sysmenu_rect.SetRect(0, 0, sysmenu_rect.right(), sysmenu_rect.bottom());
   sysmenu_rect.set_x(GetMirroredXForRect(sysmenu_rect));
   if (sysmenu_rect.Contains(point))
     return (frame_component == HTCLIENT) ? HTCLIENT : HTSYSMENU;
 
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   // Then see if the point is within any of the window controls.
   if (close_button_->IsVisible() &&
       close_button_->GetMirroredBounds().Contains(point))
     return HTCLOSE;
 
   int window_component = GetHTComponentForFrame(point,
       NonClientBorderThickness(), NonClientBorderThickness(),
       kResizeAreaCornerSize, kResizeAreaCornerSize,
-      frame_->GetWindow()->window_delegate()->CanResize());
+      frame_->window_delegate()->CanResize());
   // Fall back to the caption if no other component matches.
   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
 }
 
 void AppPanelBrowserFrameView::GetWindowMask(const gfx::Size& size,
                                              gfx::Path* window_mask) {
   DCHECK(window_mask);
 
-  if (frame_->GetWindow()->IsMaximized())
+  if (frame_->IsMaximized())
     return;
 
   // Redefine the window visible region for the new size.
   window_mask->moveTo(0, 3);
   window_mask->lineTo(1, 2);
   window_mask->lineTo(1, 1);
   window_mask->lineTo(2, 1);
   window_mask->lineTo(3, 0);
 
   window_mask->lineTo(SkIntToScalar(size.width() - 3), 0);
@@ skipping 18 matching lines @@
 
 void AppPanelBrowserFrameView::UpdateWindowIcon() {
   window_icon_->SchedulePaint();
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // AppPanelBrowserFrameView, views::View overrides:
 
 void AppPanelBrowserFrameView::OnPaint(gfx::Canvas* canvas) {
-  views::Window* window = frame_->GetWindow();
-  if (window->IsMaximized())
+  if (frame_->IsMaximized())
     PaintMaximizedFrameBorder(canvas);
   else
     PaintRestoredFrameBorder(canvas);
   PaintTitleBar(canvas);
-  if (!window->IsMaximized())
+  if (!frame_->IsMaximized())
     PaintRestoredClientEdge(canvas);
 }
 
 void AppPanelBrowserFrameView::Layout() {
   LayoutWindowControls();
   LayoutTitleBar();
   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AppPanelBrowserFrameView, views::ButtonListener implementation:
 
 void AppPanelBrowserFrameView::ButtonPressed(views::Button* sender,
                                              const views::Event& event) {
   if (sender == close_button_)
-    frame_->GetWindow()->CloseWindow();
+    frame_->Close();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AppPanelBrowserFrameView, TabIconView::TabContentsProvider implementation:
 
 bool AppPanelBrowserFrameView::ShouldTabIconViewAnimate() const {
   // This function is queried during the creation of the window as the
   // TabIconView we host is initialized, so we need to NULL check the selected
   // TabContents because in this condition there is not yet a selected tab.
   TabContents* current_tab = browser_view_->GetSelectedTabContents();
   return current_tab ? current_tab->is_loading() : false;
 }
 
 SkBitmap AppPanelBrowserFrameView::GetFaviconForTabIconView() {
-  return frame_->GetWindow()->window_delegate()->GetWindowIcon();
+  return frame_->window_delegate()->GetWindowIcon();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AppPanelBrowserFrameView, private:
 
 int AppPanelBrowserFrameView::FrameBorderThickness() const {
-  return frame_->GetWindow()->IsMaximized() ? 0 : kFrameBorderThickness;
+  return frame_->IsMaximized() ? 0 : kFrameBorderThickness;
 }
 
 int AppPanelBrowserFrameView::NonClientBorderThickness() const {
   return FrameBorderThickness() +
-      (frame_->GetWindow()->IsMaximized() ? 0 : kClientEdgeThickness);
+      (frame_->IsMaximized() ? 0 : kClientEdgeThickness);
 }
 
 int AppPanelBrowserFrameView::NonClientTopBorderHeight() const {
   return std::max(FrameBorderThickness() + IconSize(),
                   FrameBorderThickness() + kCaptionButtonHeightWithPadding) +
       TitlebarBottomThickness();
 }
 
 int AppPanelBrowserFrameView::TitlebarBottomThickness() const {
   return kTitlebarTopAndBottomEdgeThickness +
-      (frame_->GetWindow()->IsMaximized() ? 0 : kClientEdgeThickness);
+      (frame_->IsMaximized() ? 0 : kClientEdgeThickness);
 }
 
 int AppPanelBrowserFrameView::IconSize() const {
 #if defined(OS_WIN)
   // This metric scales up if either the titlebar height or the titlebar font
   // size are increased.
   return GetSystemMetrics(SM_CYSMICON);
 #else
   return std::max(BrowserFrame::GetTitleFont().height(), kIconMinimumSize);
 #endif
 }
 
 gfx::Rect AppPanelBrowserFrameView::IconBounds() const {
   int size = IconSize();
   int frame_thickness = FrameBorderThickness();
   // Our frame border has a different "3D look" than Windows'.  Theirs has a
   // more complex gradient on the top that they push their icon/title below;
   // then the maximized window cuts this off and the icon/title are centered
   // in the remaining space.  Because the apparent shape of our border is
   // simpler, using the same positioning makes things look slightly uncentered
   // with restored windows, so when the window is restored, instead of
   // calculating the remaining space from below the frame border, we calculate
   // from below the top border-plus-padding.
-  int unavailable_px_at_top = frame_->GetWindow()->IsMaximized() ?
+  int unavailable_px_at_top = frame_->IsMaximized() ?
       frame_thickness : kTitlebarTopAndBottomEdgeThickness;
   // When the icon is shorter than the minimum space we reserve for the caption
   // button, we vertically center it.  We want to bias rounding to put extra
   // space above the icon, since the 3D edge (+ client edge, for restored
   // windows) below looks (to the eye) more like additional space than does the
   // border + padding (or nothing at all, for maximized windows) above; hence
   // the +1.
   int y = unavailable_px_at_top + (NonClientTopBorderHeight() -
       unavailable_px_at_top - size - TitlebarBottomThickness() + 1) / 2;
   return gfx::Rect(frame_thickness + kIconLeftSpacing, y, size, size);
@@ skipping 77 matching lines @@
 
   SkBitmap* frame_image = rb.GetBitmapNamed(IDR_FRAME_APP_PANEL);
   canvas->TileImageInt(*frame_image, 0, FrameBorderThickness(), width(),
                        frame_image->height());
 
   // The bottom of the titlebar actually comes from the top of the Client Edge
   // graphic, with the actual client edge clipped off the bottom.
   SkBitmap* titlebar_bottom = rb.GetBitmapNamed(IDR_APP_TOP_CENTER);
   int edge_height = titlebar_bottom->height() - kClientEdgeThickness;
   canvas->TileImageInt(*titlebar_bottom, 0,
-                       frame_->GetWindow()->client_view()->y() - edge_height,
+                       frame_->client_view()->y() - edge_height,
                        width(), edge_height);
 }
 
 void AppPanelBrowserFrameView::PaintTitleBar(gfx::Canvas* canvas) {
   // The window icon is painted by the TabIconView.
-  views::WindowDelegate* d = frame_->GetWindow()->window_delegate();
+  views::WindowDelegate* d = frame_->window_delegate();
   canvas->DrawStringInt(d->GetWindowTitle(), BrowserFrame::GetTitleFont(),
       SK_ColorBLACK, GetMirroredXForRect(title_bounds_), title_bounds_.y(),
       title_bounds_.width(), title_bounds_.height());
 }
 
 void AppPanelBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
   int client_area_top = client_area_bounds.y();
 
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
@@ skipping 39 matching lines @@
   canvas->DrawRectInt(ResourceBundle::toolbar_color,
       client_area_bounds.x() - kClientEdgeThickness,
       client_area_top - kClientEdgeThickness,
       client_area_bounds.width() + kClientEdgeThickness,
       client_area_bottom - client_area_top + kClientEdgeThickness);
 }
 
 void AppPanelBrowserFrameView::LayoutWindowControls() {
   close_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                    views::ImageButton::ALIGN_BOTTOM);
-  bool is_maximized = frame_->GetWindow()->IsMaximized();
+  bool is_maximized = frame_->IsMaximized();
   // There should always be the same number of non-border pixels visible to the
   // side of the close button.  In maximized mode we extend the button to the
   // screen corner to obey Fitts' Law.
   int right_extra_width = is_maximized ? kCloseButtonFrameBorderSpacing : 0;
   gfx::Size close_button_size = close_button_->GetPreferredSize();
   int close_button_y =
       (NonClientTopBorderHeight() - close_button_size.height()) / 2;
   int top_extra_height = is_maximized ? close_button_y : 0;
   close_button_->SetBounds(width() - FrameBorderThickness() -
       kCloseButtonFrameBorderSpacing - close_button_size.width(),
@@ skipping 22 matching lines @@
 }
 
 gfx::Rect AppPanelBrowserFrameView::CalculateClientAreaBounds(int width,
     int height) const {
   int top_height = NonClientTopBorderHeight();
   int border_thickness = NonClientBorderThickness();
   return gfx::Rect(border_thickness, top_height,
                    std::max(0, width - (2 * border_thickness)),
                    std::max(0, height - top_height - border_thickness));
 }