Aura: Add --aura-laptop-mode to fill the workspace with a single window.

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 <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 23 matching lines @@
 #include "ui/base/theme_provider.h"
 #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/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
 
 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.
 const int kFrameBorderThickness = 4;
 // Besides the frame border, there's another 11 px of empty space atop the
 // window in restored mode, to use to drag the window around.
@@ skipping 69 matching lines @@
           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) {
   ui::ThemeProvider* tp = frame->GetThemeProvider();
   SkColor color = tp->GetColor(ThemeService::COLOR_BUTTON_BACKGROUND);
   SkBitmap* background =
       tp->GetBitmapNamed(IDR_THEME_WINDOW_CONTROL_BACKGROUND);
+  // TODO(jamescook): Refactor button setup into one button setup function.
   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()) {
     minimize_button_->SetBackground(color, background,
         tp->GetBitmapNamed(IDR_MINIMIZE_BUTTON_MASK));
   }
   minimize_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_MINIMIZE));
   AddChildView(minimize_button_);
-#if defined(USE_AURA)
-  // TODO(jamescook): Remove this when Aura uses its own custom window frame,
-  // BrowserNonClientFrameViewAura.  Layout code depends on this button's
-  // position, so just hide it.
-  minimize_button_->SetVisible(false);
-#endif
 
   maximize_button_->SetImage(views::CustomButton::BS_NORMAL,
                              tp->GetBitmapNamed(IDR_MAXIMIZE));
   maximize_button_->SetImage(views::CustomButton::BS_HOT,
                              tp->GetBitmapNamed(IDR_MAXIMIZE_H));
   maximize_button_->SetImage(views::CustomButton::BS_PUSHED,
                              tp->GetBitmapNamed(IDR_MAXIMIZE_P));
   if (browser_view->IsBrowserTypeNormal()) {
     maximize_button_->SetBackground(color, background,
         tp->GetBitmapNamed(IDR_MAXIMIZE_BUTTON_MASK));
@@ skipping 852 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());
 
-#if defined(OS_CHROMEOS) && !defined(USE_AURA)
-  // 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);
+  // Both ChromeOS and Aura laptop mode use a single main window.
+  bool single_window_mode = false;
+#if defined(USE_AURA)

[sky, 2011/12/12 15:46:29]

How about a IsSingleWindow() on BrowserFrame?

[James Cook, 2011/12/12 18:33:36]

Oh, good idea!  Done.

+  single_window_mode =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kAuraLaptopMode);
+#elif defined(OS_CHROMEOS)
+  single_window_mode = true;
+#endif
+  if (single_window_mode) {
+    // 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);
+      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;
     }
-
-    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()->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)
+#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());
 }
@@ skipping 45 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));
 }