Ash: Remove compact window mode.

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

 // Copyright (c) 2012 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 <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 24 matching lines @@
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/path.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/window/frame_background.h"
 #include "ui/views/window/window_shape.h"
 
-#if defined(USE_AURA)
-#include "ui/aura/aura_switches.h"
-#endif
-
 #if defined(USE_VIRTUAL_KEYBOARD)
 #include "chrome/browser/ui/virtual_keyboard/virtual_keyboard_manager.h"
 #endif
 
 using content::WebContents;
 
 namespace {
 
 // The frame border is only visible in restored mode and is hardcoded to 4 px on
 // each side regardless of the system window border size.
@@ skipping 433 matching lines @@
   return FrameBorderThickness(false) - kTopResizeAdjust;
 }
 
 int OpaqueBrowserFrameView::NonClientBorderThickness() const {
   // When we fill the screen, we don't show a client edge.
   return FrameBorderThickness(false) +
       ((frame()->IsMaximized() || frame()->IsFullscreen()) ?
        0 : kClientEdgeThickness);
 }
 
-void OpaqueBrowserFrameView::ModifyMaximizedFramePainting(
-    int* theme_offset,
-    SkBitmap** theme_frame,
-    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()->IsMaximized()) ?
       FrameBorderThickness(false) : kFrameShadowThickness;
 }
 
 int OpaqueBrowserFrameView::TitlebarBottomThickness(bool restored) const {
   return kTitlebarTopAndBottomEdgeThickness +
       ((!restored && frame()->IsMaximized()) ? 0 : kClientEdgeThickness);
@@ skipping 47 matching lines @@
   frame_background_->set_theme_bitmap(GetFrameBitmap());
   frame_background_->set_theme_overlay_bitmap(GetFrameOverlayBitmap());
   frame_background_->set_top_area_height(GetTopAreaHeight());
 
   ui::ThemeProvider* tp = GetThemeProvider();
   frame_background_->SetSideImages(
       tp->GetBitmapNamed(IDR_WINDOW_LEFT_SIDE),
       tp->GetBitmapNamed(IDR_WINDOW_TOP_CENTER),
       tp->GetBitmapNamed(IDR_WINDOW_RIGHT_SIDE),
       tp->GetBitmapNamed(IDR_WINDOW_BOTTOM_CENTER));
-#if defined(USE_AURA)
-  // TODO(jamescook): Remove this when Aura defaults to its own window frame,
-  // BrowserNonClientFrameViewAura.  Until then, use custom square corners to
-  // avoid performance penalties associated with transparent layers.
-  frame_background_->SetCornerImages(
-      tp->GetBitmapNamed(IDR_AURA_WINDOW_TOP_LEFT),
-      tp->GetBitmapNamed(IDR_AURA_WINDOW_TOP_RIGHT),
-      tp->GetBitmapNamed(IDR_AURA_WINDOW_BOTTOM_LEFT),
-      tp->GetBitmapNamed(IDR_AURA_WINDOW_BOTTOM_RIGHT));
-#else
   frame_background_->SetCornerImages(
       tp->GetBitmapNamed(IDR_WINDOW_TOP_LEFT_CORNER),
       tp->GetBitmapNamed(IDR_WINDOW_TOP_RIGHT_CORNER),
       tp->GetBitmapNamed(IDR_WINDOW_BOTTOM_LEFT_CORNER),
       tp->GetBitmapNamed(IDR_WINDOW_BOTTOM_RIGHT_CORNER));
-#endif
   frame_background_->PaintRestored(canvas, this);
 
   // Note: When we don't have a toolbar, we need to draw some kind of bottom
   // edge here.  Because the App Window graphics we use for this have an
   // attached client edge and their sizing algorithm is a little involved, we do
   // all this in PaintRestoredClientEdge().
 }
 
 void OpaqueBrowserFrameView::PaintMaximizedFrameBorder(gfx::Canvas* canvas) {
   frame_background_->set_frame_color(GetFrameColor());
   frame_background_->set_theme_bitmap(GetFrameBitmap());
   frame_background_->set_theme_overlay_bitmap(GetFrameOverlayBitmap());
   frame_background_->set_top_area_height(GetTopAreaHeight());
 
-  // Allow customization of these attributes.
-  SkBitmap* theme_frame = NULL;
-  SkBitmap* left = NULL;
-  SkBitmap* right = NULL;
-  int top_offset = 0;
-  ModifyMaximizedFramePainting(&top_offset, &theme_frame, &left, &right);
-  frame_background_->SetMaximizedCorners(left, right, top_offset);
-  // If user has a theme installed, theme_frame would be NULL and
-  // frame_background_ is unchanged.
-  if (theme_frame)
-    frame_background_->set_theme_bitmap(theme_frame);
-
   // Theme frame must be aligned with the tabstrip as if we were
   // in restored mode.  Note that the top of the tabstrip is
   // kTabstripTopShadowThickness px off the top of the screen.
   int theme_background_y = -(GetHorizontalTabStripVerticalOffset(true) +
       kTabstripTopShadowThickness);
   frame_background_->set_theme_background_y(theme_background_y);
 
   frame_background_->PaintMaximized(canvas, this);
 
   // TODO(jamescook): Migrate this into FrameBackground.
@@ skipping 292 matching lines @@
   // 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());
 
-  // Both ChromeOS and Aura laptop mode use a single main window.
-  if (frame()->IsSingleWindowMode()) {
-    // LayoutWindowControls could be triggered from
-    // NativeWidgetGtk::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()->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;
-    }
-  }
-  // Aura can transition in and out of single-window mode, so be sure the
-  // close button is visible after the change.
-  close_button_->SetVisible(true);
-
   // When the window is restored, we show a maximized button; otherwise, we show
   // a restore button.
   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());
 
-#if defined(USE_AURA)
-  // TODO(jamescook): Go back to showing minimize button when Aura uses its
-  // own custom window frame, BrowserNonClientFrameViewAura.
-  minimize_button_->SetVisible(false);
-#else
   minimize_button_->SetVisible(true);
-#endif
   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() {
@@ skipping 43 matching lines @@
 
 gfx::Rect OpaqueBrowserFrameView::CalculateClientAreaBounds(int width,
                                                             int height) const {
   int top_height = NonClientTopBorderHeight(false);
   int border_thickness = NonClientBorderThickness();
   return gfx::Rect(border_thickness, top_height,
                    std::max(0, width - (2 * border_thickness)),
                    std::max(0, height - GetReservedHeight() -
                        top_height - border_thickness));
 }