Re-land:

chrome/browser/ui/views/frame/opaque_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/opaque_browser_frame_view.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 120 matching lines @@
           minimize_button_(new views::ImageButton(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           maximize_button_(new views::ImageButton(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           restore_button_(new views::ImageButton(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           close_button_(new views::ImageButton(this))),
       window_icon_(NULL),
       frame_(frame),
       browser_view_(browser_view) {
-  ui::ThemeProvider* tp = frame_->GetThemeProviderForFrame();
+  ui::ThemeProvider* tp = frame_->GetThemeProvider();
   SkColor color = tp->GetColor(ThemeService::COLOR_BUTTON_BACKGROUND);
   SkBitmap* background =
       tp->GetBitmapNamed(IDR_THEME_WINDOW_CONTROL_BACKGROUND);
   minimize_button_->SetImage(views::CustomButton::BS_NORMAL,
                              tp->GetBitmapNamed(IDR_MINIMIZE));
   minimize_button_->SetImage(views::CustomButton::BS_HOT,
                              tp->GetBitmapNamed(IDR_MINIMIZE_H));
   minimize_button_->SetImage(views::CustomButton::BS_PUSHED,
                              tp->GetBitmapNamed(IDR_MINIMIZE_P));
   if (browser_view_->IsBrowserTypeNormal()) {
@@ skipping 84 matching lines @@
   return gfx::Rect(
       client_view_bounds.x(),
       client_view_bounds.y() + client_view_bounds.height(),
       client_view_bounds.width(),
       GetReservedHeight());
 }
 
 int OpaqueBrowserFrameView::NonClientTopBorderHeight(
     bool restored,
     bool ignore_vertical_tabs) const {
-  views::Window* window = frame_->GetWindow();
-  views::WindowDelegate* delegate = window->window_delegate();
+  views::WindowDelegate* delegate = frame_->window_delegate();
   // |delegate| may be NULL if called from callback of InputMethodChanged while
   // a window is being destroyed.
   // See more discussion at http://crosbug.com/8958
   if ((delegate && delegate->ShouldShowWindowTitle()) ||
       (browser_view_->IsTabStripVisible() && !ignore_vertical_tabs &&
        browser_view_->UseVerticalTabs())) {
     return std::max(FrameBorderThickness(restored) + IconSize(),
         CaptionButtonY(restored) + kCaptionButtonHeightWithPadding) +
         TitlebarBottomThickness(restored);
   }
 
   return FrameBorderThickness(restored) -
       ((browser_view_->IsTabStripVisible() && !restored &&
-      window->IsMaximized()) ? kTabstripTopShadowThickness : 0);
+      frame_->IsMaximized()) ? kTabstripTopShadowThickness : 0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, BrowserNonClientFrameView implementation:
 
 gfx::Rect OpaqueBrowserFrameView::GetBoundsForTabStrip(
     views::View* tabstrip) const {
   if (!tabstrip) {
     return gfx::Rect();
   }
 
   if (browser_view_->UseVerticalTabs()) {
     gfx::Size ps = tabstrip->GetPreferredSize();
     return gfx::Rect(NonClientBorderThickness(),
         NonClientTopBorderHeight(false, false), ps.width(),
         browser_view_->height());
   }
 
   int tabstrip_x = browser_view_->ShouldShowOffTheRecordAvatar() ?
       (otr_avatar_bounds_.right() + kOTRSideSpacing) :
       NonClientBorderThickness() + kTabStripIndent;
 
   int maximized_spacing =
       kNewTabCaptionMaximizedSpacing +
       (show_profile_button() && profile_button_->IsVisible() ?
           profile_button_->GetPreferredSize().width() +
               ProfileMenuButton::kProfileTagHorizontalSpacing : 0);
   int tabstrip_width = minimize_button_->x() - tabstrip_x -
-      (frame_->GetWindow()->IsMaximized() ?
+      (frame_->IsMaximized() ?
           maximized_spacing : kNewTabCaptionRestoredSpacing);
   int tabstrip_height = 0;
   if (tabstrip)
     tabstrip_height = tabstrip->GetPreferredSize().height();
   return gfx::Rect(tabstrip_x, GetHorizontalTabStripVerticalOffset(false),
                    std::max(0, tabstrip_width), tabstrip_height);
 }
 
 int OpaqueBrowserFrameView::GetHorizontalTabStripVerticalOffset(
     bool restored) const {
   return NonClientTopBorderHeight(restored, true) + ((!restored &&
-      (frame_->GetWindow()->IsMaximized() ||
-      frame_->GetWindow()->IsFullscreen())) ?
+      (frame_->IsMaximized() ||
+      frame_->IsFullscreen())) ?
       0 : kNonClientRestoredExtraThickness);
 }
 
 void OpaqueBrowserFrameView::UpdateThrobber(bool running) {
   if (window_icon_)
     window_icon_->Update();
 }
 
 gfx::Size OpaqueBrowserFrameView::GetMinimumSize() {
   gfx::Size min_size(browser_view_->GetMinimumSize());
   int border_thickness = NonClientBorderThickness();
   min_size.Enlarge(2 * border_thickness,
                    NonClientTopBorderHeight(false, false) + border_thickness);
 
-  views::WindowDelegate* delegate = frame_->GetWindow()->window_delegate();
+  views::WindowDelegate* delegate = frame_->window_delegate();
   int min_titlebar_width = (2 * FrameBorderThickness(false)) +
       kIconLeftSpacing +
       (delegate && delegate->ShouldShowWindowIcon() ?
        (IconSize() + kTitleLogoSpacing) : 0);
 #if !defined(OS_CHROMEOS)
   min_titlebar_width +=
       minimize_button_->GetMinimumSize().width() +
       restore_button_->GetMinimumSize().width() +
       close_button_->GetMinimumSize().width();
 #endif
@@ skipping 24 matching lines @@
                    std::max(0, client_bounds.y() - top_height),
                    client_bounds.width() + (2 * border_thickness),
                    client_bounds.height() + top_height + border_thickness);
 }
 
 int OpaqueBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
   if (!bounds().Contains(point))
     return HTNOWHERE;
 
   int frame_component =
-      frame_->GetWindow()->client_view()->NonClientHitTest(point);
+      frame_->client_view()->NonClientHitTest(point);
 
   // See if we're in the sysmenu region.  We still have to check the tabstrip
   // first so that clicks in a tab don't get treated as sysmenu clicks.
   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;
   if (restore_button_->IsVisible() &&
       restore_button_->GetMirroredBounds().Contains(point))
     return HTMAXBUTTON;
   if (maximize_button_->IsVisible() &&
       maximize_button_->GetMirroredBounds().Contains(point))
     return HTMAXBUTTON;
   if (minimize_button_->IsVisible() &&
       minimize_button_->GetMirroredBounds().Contains(point))
     return HTMINBUTTON;
 
   // See if the point is within the profile menu button.
   if (show_profile_button() && profile_button_->IsVisible() &&
       profile_button_->GetMirroredBounds().Contains(point))
     return HTCLIENT;
 
-  views::WindowDelegate* delegate = frame_->GetWindow()->window_delegate();
+  views::WindowDelegate* delegate = frame_->window_delegate();
   if (!delegate) {
     LOG(WARNING) << "delegate is NULL, returning safe default.";
     return HTCAPTION;
   }
   int window_component = GetHTComponentForFrame(point, TopResizeHeight(),
       NonClientBorderThickness(), kResizeAreaCornerSize, kResizeAreaCornerSize,
       delegate->CanResize());
   // Fall back to the caption if no other component matches.
   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
 }
 
 void OpaqueBrowserFrameView::GetWindowMask(const gfx::Size& size,
                                            gfx::Path* window_mask) {
   DCHECK(window_mask);
 
-  if (frame_->GetWindow()->IsMaximized() || frame_->GetWindow()->IsFullscreen())
+  if (frame_->IsMaximized() || frame_->IsFullscreen())
     return;
 
   views::GetDefaultWindowMask(size, window_mask);
 }
 
 void OpaqueBrowserFrameView::EnableClose(bool enable) {
   close_button_->SetEnabled(enable);
 }
 
 void OpaqueBrowserFrameView::ResetWindowControls() {
@@ skipping 15 matching lines @@
     profile_menu_model_.reset(new ProfileMenuModel);
   gfx::Point menu_point(pt.x(),
                         pt.y() + kMenuDisplayOffset);
   profile_menu_model_->RunMenuAt(menu_point);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, views::View overrides:
 
 void OpaqueBrowserFrameView::OnPaint(gfx::Canvas* canvas) {
-  views::Window* window = frame_->GetWindow();
-  if (window->IsFullscreen())
+  if (frame_->IsFullscreen())
     return;  // Nothing is visible, so don't bother to paint.
 
-  if (window->IsMaximized())
+  if (frame_->IsMaximized())
     PaintMaximizedFrameBorder(canvas);
   else
     PaintRestoredFrameBorder(canvas);
   PaintTitleBar(canvas);
   if (browser_view_->IsToolbarVisible() ||
       browser_view_->UseCompactNavigationBar())
     PaintToolbarBackground(canvas);
   if (browser_view_->ShouldShowOffTheRecordAvatar())
     PaintOTRAvatar(canvas);
-  if (!window->IsMaximized())
+  if (!frame_->IsMaximized())
     PaintRestoredClientEdge(canvas);
 }
 
 void OpaqueBrowserFrameView::Layout() {
   LayoutWindowControls();
   LayoutTitleBar();
   LayoutOTRAvatar();
   LayoutProfileTag();
   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
 }
 
 bool OpaqueBrowserFrameView::HitTest(const gfx::Point& l) const {
   // If the point is outside the bounds of the client area, claim it.
   bool in_nonclient = NonClientFrameView::HitTest(l);
   if (in_nonclient)
     return in_nonclient;
 
   // Otherwise claim it only if it's in a non-tab portion of the tabstrip.
   bool vertical_tabs = browser_view_->UseVerticalTabs();
   gfx::Rect tabstrip_bounds = GetBoundsForTabStrip(browser_view_->tabstrip());
   gfx::Point tabstrip_origin(tabstrip_bounds.origin());
-  View::ConvertPointToView(frame_->GetWindow()->client_view(),
-                           this, &tabstrip_origin);
+  View::ConvertPointToView(frame_->client_view(), this, &tabstrip_origin);
   tabstrip_bounds.set_origin(tabstrip_origin);
   if ((!vertical_tabs && l.y() > tabstrip_bounds.bottom()) ||
       (vertical_tabs && l.x() > tabstrip_bounds.right())) {
     return false;
   }
 
   // Claim it only if we're also not in the compact navigation buttons.
   if (browser_view_->UseCompactNavigationBar()) {
     if (ConvertedContainsCheck(browser_view_->GetCompactNavigationBarBounds(),
-                               frame_->GetWindow()->client_view(),
+                               frame_->client_view(),
                                static_cast<const View*>(this),
                                l)) {
       return false;
     }
     if (ConvertedContainsCheck(browser_view_->GetCompactOptionsBarBounds(),
-                               frame_->GetWindow()->client_view(),
+                               frame_->client_view(),
                                static_cast<const View*>(this),
                                l)) {
       return false;
     }
   }
 
   // We convert from our parent's coordinates since we assume we fill its bounds
   // completely. We need to do this since we're not a parent of the tabstrip,
   // meaning ConvertPointToView would otherwise return something bogus.
   gfx::Point browser_view_point(l);
   View::ConvertPointToView(parent(), browser_view_, &browser_view_point);
   return browser_view_->IsPositionInWindowCaption(browser_view_point);
 }
 
 void OpaqueBrowserFrameView::GetAccessibleState(
     ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_TITLEBAR;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, views::ButtonListener implementation:
 
 void OpaqueBrowserFrameView::ButtonPressed(views::Button* sender,
                                            const views::Event& event) {
-  views::Window* window = frame_->GetWindow();
   if (sender == minimize_button_)
-    window->Minimize();
+    frame_->Minimize();
   else if (sender == maximize_button_)
-    window->Maximize();
+    frame_->Maximize();
   else if (sender == restore_button_)
-    window->Restore();
+    frame_->Restore();
   else if (sender == close_button_)
-    window->CloseWindow();
+    frame_->Close();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, TabIconView::TabContentsProvider implementation:
 
 bool OpaqueBrowserFrameView::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 OpaqueBrowserFrameView::GetFaviconForTabIconView() {
-  views::WindowDelegate* delegate = frame_->GetWindow()->window_delegate();
+  views::WindowDelegate* delegate = frame_->window_delegate();
   if (!delegate) {
     LOG(WARNING) << "delegate is NULL, returning safe default.";
     return SkBitmap();
   }
   return delegate->GetWindowIcon();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, protected:
 
 void OpaqueBrowserFrameView::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK_EQ(NotificationType::PREF_CHANGED, type.value);
   std::string* name = Details<std::string>(details).ptr();
   if (prefs::kGoogleServicesUsername == *name)
     LayoutProfileTag();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, private:
 
 int OpaqueBrowserFrameView::FrameBorderThickness(bool restored) const {
-  views::Window* window = frame_->GetWindow();
-  return (!restored && (window->IsMaximized() || window->IsFullscreen())) ?
+  return (!restored && (frame_->IsMaximized() || frame_->IsFullscreen())) ?
       0 : kFrameBorderThickness;
 }
 
 int OpaqueBrowserFrameView::TopResizeHeight() const {
   return FrameBorderThickness(false) - kTopResizeAdjust;
 }
 
 int OpaqueBrowserFrameView::NonClientBorderThickness() const {
   // When we fill the screen, we don't show a client edge.
-  views::Window* window = frame_->GetWindow();
   return FrameBorderThickness(false) +
-      ((window->IsMaximized() || window->IsFullscreen()) ?
+      ((frame_->IsMaximized() || frame_->IsFullscreen()) ?
        0 : kClientEdgeThickness);
 }
 
 void OpaqueBrowserFrameView::ModifyMaximizedFramePainting(
     int* theme_offset, SkBitmap** left_corner, SkBitmap** right_corner) {
 }
 
 int OpaqueBrowserFrameView::CaptionButtonY(bool restored) const {
   // Maximized buttons start at window top so that even if their images aren't
   // drawn flush with the screen edge, they still obey Fitts' Law.
-  return (!restored && frame_->GetWindow()->IsMaximized()) ?
+  return (!restored && frame_->IsMaximized()) ?
       FrameBorderThickness(false) : kFrameShadowThickness;
 }
 
 int OpaqueBrowserFrameView::TitlebarBottomThickness(bool restored) const {
   return kTitlebarTopAndBottomEdgeThickness +
-      ((!restored && frame_->GetWindow()->IsMaximized()) ?
-      0 : kClientEdgeThickness);
+      ((!restored && frame_->IsMaximized()) ? 0 : kClientEdgeThickness);
 }
 
 int OpaqueBrowserFrameView::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().GetHeight(), kIconMinimumSize);
 #endif
 }
 
 gfx::Rect OpaqueBrowserFrameView::IconBounds() const {
   int size = IconSize();
   int frame_thickness = FrameBorderThickness(false);
   int y;
-  views::WindowDelegate* delegate = frame_->GetWindow()->window_delegate();
+  views::WindowDelegate* delegate = frame_->window_delegate();
   if (delegate && (delegate->ShouldShowWindowIcon() ||
                    delegate->ShouldShowWindowTitle())) {
     // 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 3D edge.
-    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 3D edge (or nothing at all, for maximized windows) above;
     // hence the +1.
     y = unavailable_px_at_top + (NonClientTopBorderHeight(false, false) -
         unavailable_px_at_top - size - TitlebarBottomThickness(false) + 1) / 2;
   } else {
@@ skipping 116 matching lines @@
   canvas->DrawBitmapInt(*bottom_left_corner, 0,
                         height() - bottom_left_corner->height());
 
   // Left.
   canvas->TileImageInt(*left_edge, 0, top_left_height, left_edge->width(),
       height() - top_left_height - bottom_left_corner->height());
 }
 
 void OpaqueBrowserFrameView::PaintMaximizedFrameBorder(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
-  views::Window* window = frame_->GetWindow();
-
   // Window frame mode and color
   SkBitmap* theme_frame;
 
   // Allow customization of these attributes.
   SkBitmap* left = NULL;
   SkBitmap* right = NULL;
   int top_offset = 0;
   ModifyMaximizedFramePainting(&top_offset, &left, &right);
 
   // Never theme app and popup windows.
@@ skipping 38 matching lines @@
   }
 
   if (!browser_view_->IsToolbarVisible()) {
     // There's no toolbar to edge the frame border, so we need to draw a bottom
     // edge.  The graphic we use for this has a built in client edge, so we clip
     // it off the bottom.
     SkBitmap* top_center =
         tp->GetBitmapNamed(IDR_APP_TOP_CENTER);
     int edge_height = top_center->height() - kClientEdgeThickness;
     canvas->TileImageInt(*top_center, 0,
-        window->client_view()->y() - edge_height, width(), edge_height);
+        frame_->client_view()->y() - edge_height, width(), edge_height);
   }
 }
 
 void OpaqueBrowserFrameView::PaintTitleBar(gfx::Canvas* canvas) {
   // The window icon is painted by the TabIconView.
-  views::WindowDelegate* delegate = frame_->GetWindow()->window_delegate();
+  views::WindowDelegate* delegate = frame_->window_delegate();
   if (!delegate) {
     LOG(WARNING) << "delegate is NULL";
     return;
   }
   if (delegate->ShouldShowWindowTitle()) {
     canvas->DrawStringInt(WideToUTF16Hack(delegate->GetWindowTitle()),
                           BrowserFrame::GetTitleFont(),
         SK_ColorWHITE, GetMirroredXForRect(title_bounds_),
         title_bounds_.y(), title_bounds_.width(), title_bounds_.height());
     /* TODO(pkasting):  If this window is active, we should also draw a drop
@@ skipping 131 matching lines @@
       // as the shadows at the image top mean the apparent center is below the
       // real center.
       ((otr_avatar_icon.height() - otr_avatar_bounds_.height()) + 1) / 2, w, h,
       otr_avatar_bounds_.x(), otr_avatar_bounds_.y(), w, h, false);
 
   canvas->Restore();
 }
 
 void OpaqueBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
-  int client_area_top = frame_->GetWindow()->client_view()->y();
+  int client_area_top = frame_->client_view()->y();
   int image_top = client_area_top;
 
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
   SkColor toolbar_color = tp->GetColor(ThemeService::COLOR_TOOLBAR);
 
   if (browser_view_->IsToolbarVisible() ||
       browser_view_->UseCompactNavigationBar()) {
     // The client edge images always start below the toolbar corner images.  The
     // client edge filled rects start there or at the bottom of the toolbar,
     // whichever is shorter.
@@ skipping 65 matching lines @@
       kClientEdgeThickness,
       client_area_bottom + kClientEdgeThickness - client_area_top);
   canvas->FillRectInt(toolbar_color, client_area_bounds.x(), client_area_bottom,
                       client_area_bounds.width(), kClientEdgeThickness);
   canvas->FillRectInt(toolbar_color, client_area_bounds.right(),
       client_area_top, kClientEdgeThickness,
       client_area_bottom + kClientEdgeThickness - client_area_top);
 }
 
 void OpaqueBrowserFrameView::LayoutWindowControls() {
-  bool is_maximized = frame_->GetWindow()->IsMaximized();
+  bool is_maximized = frame_->IsMaximized();
   close_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                    views::ImageButton::ALIGN_BOTTOM);
   int caption_y = CaptionButtonY(false);
   // There should always be the same number of non-shadow pixels visible to the
   // side of the caption buttons.  In maximized mode we extend the rightmost
   // button to the screen corner to obey Fitts' Law.
   int right_extra_width = is_maximized ?
       (kFrameBorderThickness - kFrameShadowThickness) : 0;
   gfx::Size close_button_size = close_button_->GetPreferredSize();
   close_button_->SetBounds(width() - FrameBorderThickness(false) -
       right_extra_width - close_button_size.width(), caption_y,
       close_button_size.width() + right_extra_width,
       close_button_size.height());
 
 #if defined(OS_CHROMEOS)
   // LayoutWindowControls could be triggered from WindowGtk::UpdateWindowTitle,
   // which could happen when user navigates in fullscreen mode. And because
   // BrowserFrameChromeos::IsMaximized return false for fullscreen mode, we
   // explicitly test fullscreen mode here and make it use the same code path
   // as maximized mode.
   // TODO(oshima): Optimize the relayout logic to defer the frame view's
   // relayout until it is necessary, i.e when it becomes visible.
-  if (is_maximized || frame_->GetWindow()->IsFullscreen()) {
+  if (is_maximized || frame_->IsFullscreen()) {
     minimize_button_->SetVisible(false);
     restore_button_->SetVisible(false);
     maximize_button_->SetVisible(false);
 
     if (browser_view_->browser()->is_devtools()) {
       close_button_->SetVisible(true);
       minimize_button_->SetBounds(close_button_->bounds().x(), 0, 0, 0);
     } else {
       close_button_->SetVisible(false);
       // Set the bounds of the minimize button so that we don't have to change
       // other places that rely on the bounds. Put it slightly to the right
       // of the edge of the view, so that when we remove the spacing it lines
       // up with the edge.
       minimize_button_->SetBounds(width() - FrameBorderThickness(false) +
           kNewTabCaptionMaximizedSpacing, 0, 0, 0);
     }
 
     return;
   } else {
     close_button_->SetVisible(true);
   }
 #endif
 
   // When the window is restored, we show a maximized button; otherwise, we show
   // a restore button.
-  bool is_restored = !is_maximized && !frame_->GetWindow()->IsMinimized();
+  bool is_restored = !is_maximized && !frame_->IsMinimized();
   views::ImageButton* invisible_button = is_restored ?
       restore_button_ : maximize_button_;
   invisible_button->SetVisible(false);
 
   views::ImageButton* visible_button = is_restored ?
       maximize_button_ : restore_button_;
   visible_button->SetVisible(true);
   visible_button->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                     views::ImageButton::ALIGN_BOTTOM);
   gfx::Size visible_button_size = visible_button->GetPreferredSize();
   visible_button->SetBounds(close_button_->x() - visible_button_size.width(),
                             caption_y, visible_button_size.width(),
                             visible_button_size.height());
 
   minimize_button_->SetVisible(true);
   minimize_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                       views::ImageButton::ALIGN_BOTTOM);
   gfx::Size minimize_button_size = minimize_button_->GetPreferredSize();
   minimize_button_->SetBounds(
       visible_button->x() - minimize_button_size.width(), caption_y,
       minimize_button_size.width(),
       minimize_button_size.height());
 }
 
 void OpaqueBrowserFrameView::LayoutTitleBar() {
   // The window title is based on the calculated icon position, even when there
   // is no icon.
   gfx::Rect icon_bounds(IconBounds());
-  views::WindowDelegate* delegate = frame_->GetWindow()->window_delegate();
+  views::WindowDelegate* delegate = frame_->window_delegate();
   if (delegate && delegate->ShouldShowWindowIcon())
     window_icon_->SetBoundsRect(icon_bounds);
 
   // Size the title, if visible.
   if (delegate && delegate->ShouldShowWindowTitle()) {
     int title_x = delegate->ShouldShowWindowIcon() ?
         icon_bounds.right() + kIconTitleSpacing : icon_bounds.x();
     int title_height = BrowserFrame::GetTitleFont().GetHeight();
     // We bias the title position so that when the difference between the icon
     // and title heights is odd, the extra pixel of the title is above the
@@ skipping 11 matching lines @@
   SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
   int otr_bottom, otr_restored_y;
   if (browser_view_->UseVerticalTabs()) {
     otr_bottom = NonClientTopBorderHeight(false, false) - kOTRBottomSpacing;
     otr_restored_y = kFrameShadowThickness;
   } else {
     otr_bottom = GetHorizontalTabStripVerticalOffset(false) +
         browser_view_->GetTabStripHeight() - kOTRBottomSpacing;
     otr_restored_y = otr_bottom - otr_avatar_icon.height();
   }
-  int otr_y = frame_->GetWindow()->IsMaximized() ?
+  int otr_y = frame_->IsMaximized() ?
       (NonClientTopBorderHeight(false, true) + kTabstripTopShadowThickness) :
       otr_restored_y;
   otr_avatar_bounds_.SetRect(NonClientBorderThickness() + kOTRSideSpacing,
       otr_y, otr_avatar_icon.width(),
       browser_view_->ShouldShowOffTheRecordAvatar() ? (otr_bottom - otr_y) : 0);
 }
 
 void OpaqueBrowserFrameView::LayoutProfileTag() {
   if (!show_profile_button())
     return;
@@ skipping 12 matching lines @@
   profile_button_->SetVisible(true);
   int x_tag =
       // The x position of minimize button in the frame
       minimize_button_->x() -
           // - the space between the minimize button and the profile button
           ProfileMenuButton::kProfileTagHorizontalSpacing -
           // - the width of the profile button
           profile_button_->GetPreferredSize().width();
   // Adjust for different default font sizes on different Windows platforms.
   int y_tag = profile_button_->font().GetHeight() < 14 ? 2 : 0;
-  int y_maximized_offset = frame_->GetWindow()->IsMaximized() ?
+  int y_maximized_offset = frame_->IsMaximized() ?
       kProfileElementMaximizedYOffset : 0;
   profile_button_->SetBounds(
       x_tag,
       y_tag + y_maximized_offset,
       profile_button_->GetPreferredSize().width(),
       profile_button_->GetPreferredSize().height());
 
   if (!profile_name.empty()) {
     profile_tag_->SetVisible(true);
     profile_tag_->SetBounds(
@@ skipping 15 matching lines @@
                    std::max(0, width - (2 * border_thickness)),
                    std::max(0, height - GetReservedHeight() -
                        top_height - border_thickness));
 }
 
 void OpaqueBrowserFrameView::RegisterLoginNotifications() {
   PrefService* pref_service = browser_view_->browser()->profile()->GetPrefs();
   DCHECK(pref_service);
   username_pref_.Init(prefs::kGoogleServicesUsername, pref_service, this);
 }