Linux Aura: Added --use-system-title-bar flag.

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

 // Copyright 2013 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_layout.h"
 
+#include "base/command_line.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/ui/views/avatar_label.h"
 #include "chrome/browser/ui/views/avatar_menu_button.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/profile_management_switches.h"
 #include "ui/gfx/font.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.h"
 
 #if defined(OS_WIN)
 #include "win8/util/win8_util.h"
 #endif  // OS_WIN
 
 namespace {
@@ skipping 32 matching lines @@
 
 // Space between the edge of the avatar and the tabstrip.
 const int kAvatarInnerSpacing = 4;
 
 // Space between the trailing edge of the avatar label and the tabstrip.
 const int kAvatarLabelInnerSpacing = 10;
 
 // How far the new avatar button is from the closest caption button.
 const int kNewAvatarButtonOffset = 5;
 
-// In restored mode, the New Tab button isn't at the same height as the caption
+// When the title bar is in its normal two row mode (usually the case for
+// restored windows), the New Tab button isn't at the same height as the caption
 // buttons, but the space will look cluttered if it actually slides under them,
 // so we stop it when the gap between the two is down to 5 px.
-const int kNewTabCaptionRestoredSpacing = 5;
+const int kNewTabCaptionNormalSpacing = 5;
 
-// In maximized mode, where the New Tab button and the caption buttons are at
-// similar vertical coordinates, we need to reserve a larger, 16 px gap to avoid
-// looking too cluttered.
-const int kNewTabCaptionMaximizedSpacing = 16;
+// When the title bar is condensed to one row (as when maximized), the New Tab
+// button and the caption buttons are at similar vertical coordinates, so we
+// need to reserve a larger, 16 px gap to avoid looking too cluttered.
+const int kNewTabCaptionCondensedSpacing = 16;
 
 // If there are no caption buttons to the right of the New Tab button, we
 // reserve a small 5px gap, regardless of whether the window is maximized. This
 // overrides the two previous constants.
 const int kNewTabNoCaptionButtonsSpacing = 5;
 
 // The top 3 px of the tabstrip is shadow; in maximized mode we push this off
 // the top of the screen so the tabs appear flush against the screen edge.
 const int kTabstripTopShadowThickness = 3;
 
@@ skipping 111 matching lines @@
     const gfx::Rect& client_bounds) const {
   int top_height = NonClientTopBorderHeight(false);
   int border_thickness = NonClientBorderThickness();
   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 OpaqueBrowserFrameViewLayout::FrameBorderThickness(bool restored) const {
-  return (!restored && (delegate_->IsMaximized() ||
+  return (!restored && (IsTitleBarCondensed() ||
                         delegate_->IsFullscreen())) ?
       0 : kFrameBorderThickness;
 }
 
 int OpaqueBrowserFrameViewLayout::NonClientBorderThickness() const {
   // When we fill the screen, we don't show a client edge.
   return FrameBorderThickness(false) +
-      ((delegate_->IsMaximized() || delegate_->IsFullscreen()) ?
+      ((IsTitleBarCondensed() || delegate_->IsFullscreen()) ?
        0 : views::NonClientFrameView::kClientEdgeThickness);
 }
 
 int OpaqueBrowserFrameViewLayout::NonClientTopBorderHeight(
     bool restored) const {
   if (delegate_->ShouldShowWindowTitle()) {
     return std::max(FrameBorderThickness(restored) + delegate_->GetIconSize(),
         CaptionButtonY(restored) + kCaptionButtonHeightWithPadding) +
         TitlebarBottomThickness(restored);
   }
 
-  return FrameBorderThickness(restored) -
-      ((delegate_->IsTabStripVisible() &&
-          !restored && !delegate_->ShouldLeaveOffsetNearTopBorder())
-              ? kTabstripTopShadowThickness : 0);
+  int thickness = FrameBorderThickness(restored);
+  if (!restored && delegate_->IsTabStripVisible() &&
+      (!delegate_->ShouldLeaveOffsetNearTopBorder() || IsTitleBarCondensed())) {
+    thickness -= kTabstripTopShadowThickness;
+  }
+  return thickness;
 }
 
 int OpaqueBrowserFrameViewLayout::GetTabStripInsetsTop(bool restored) const {
   return NonClientTopBorderHeight(restored) + ((!restored &&
       (!delegate_->ShouldLeaveOffsetNearTopBorder() ||
+      IsTitleBarCondensed() ||
       delegate_->IsFullscreen())) ?
       0 : kNonClientRestoredExtraThickness);
 }
 
 int OpaqueBrowserFrameViewLayout::TitlebarBottomThickness(bool restored) const {
   return kTitlebarTopAndBottomEdgeThickness +
-      ((!restored && delegate_->IsMaximized()) ? 0 :
+      ((!restored && IsTitleBarCondensed()) ? 0 :
        views::NonClientFrameView::kClientEdgeThickness);
 }
 
 int OpaqueBrowserFrameViewLayout::CaptionButtonY(bool restored) const {
   // Maximized buttons start at window top, since the window has no border. This
   // offset is for the image (the actual clickable bounds extend all the way to
   // the top to take Fitts' Law into account).
-  return ((!restored && delegate_->IsMaximized()) ?
+  return ((!restored && IsTitleBarCondensed()) ?
       FrameBorderThickness(false) :
           views::NonClientFrameView::kFrameShadowThickness) + extra_caption_y_;
 }
 
 gfx::Rect OpaqueBrowserFrameViewLayout::IconBounds() const {
   return window_icon_bounds_;
 }
 
 gfx::Rect OpaqueBrowserFrameViewLayout::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 - top_height - border_thickness));
 }
 
+bool OpaqueBrowserFrameViewLayout::IsTitleBarCondensed() const {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseSystemTitleBar))
+    return true;
+#endif
+
+  return delegate_->IsMaximized();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, private:
 
 bool OpaqueBrowserFrameViewLayout::ShouldAvatarBeOnRight() const {
   // The avatar should be shown either on the end of the left or the beginning
   // of the right depending on which side has fewer buttons.
   return trailing_buttons_.size() < leading_buttons_.size();
 }
 
 int OpaqueBrowserFrameViewLayout::NewTabCaptionSpacing() const {
   return has_trailing_buttons_
-             ? (delegate_->IsMaximized() ? kNewTabCaptionMaximizedSpacing
-                                         : kNewTabCaptionRestoredSpacing)
+             ? (IsTitleBarCondensed() ? kNewTabCaptionCondensedSpacing
+                                      : kNewTabCaptionNormalSpacing)
              : kNewTabNoCaptionButtonsSpacing;
 }
 
 void OpaqueBrowserFrameViewLayout::LayoutWindowControls(views::View* host) {
   if (!ShouldAddDefaultCaptionButtons())
     return;
 
   int caption_y = CaptionButtonY(false);
 
   // Keep a list of all buttons that we don't show.
@@ skipping 38 matching lines @@
     use_hidden_icon_location = false;
 
     // 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 = delegate_->IsMaximized() ?
+    int unavailable_px_at_top = IsTitleBarCondensed() ?
         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.
     int y = unavailable_px_at_top + (NonClientTopBorderHeight(false) -
                                      unavailable_px_at_top - size -
                                      TitlebarBottomThickness(false) + 1) / 2;
@@ skipping 65 matching lines @@
   gfx::ImageSkia incognito_icon = delegate_->GetOTRAvatarIcon();
 
   bool avatar_on_right = ShouldAvatarBeOnRight();
   int avatar_bottom = GetTabStripInsetsTop(false) +
       delegate_->GetTabStripHeight() - kAvatarBottomSpacing;
   int avatar_restored_y = avatar_bottom - incognito_icon.height();
   int avatar_x = avatar_on_right ?
       host->width() - trailing_button_start_ - kAvatarOuterSpacing -
           incognito_icon.width() :
       leading_button_start_ + kAvatarOuterSpacing;
-  int avatar_y = delegate_->IsMaximized() ?
+  int avatar_y = IsTitleBarCondensed() ?
       (NonClientTopBorderHeight(false) + kTabstripTopShadowThickness) :
       avatar_restored_y;
   avatar_bounds_.SetRect(
       avatar_x,
       avatar_y,
       incognito_icon.width(),
       delegate_->ShouldShowAvatar() ? (avatar_bottom - avatar_y) : 0);
   if (avatar_button_) {
     avatar_button_->set_button_on_right(avatar_on_right);
     avatar_button_->SetBoundsRect(avatar_bounds_);
@@ skipping 88 matching lines @@
 
   button->SetImageAlignment(
       (alignment == ALIGN_LEADING)  ?
           views::ImageButton::ALIGN_RIGHT : views::ImageButton::ALIGN_LEFT,
       views::ImageButton::ALIGN_BOTTOM);
 
   // There should always be the same number of non-shadow pixels visible to the
   // side of the caption buttons.  In maximized mode we extend buttons to the
   // screen top and the rightmost button to the screen right (or leftmost button
   // to the screen left, for left-aligned buttons) to obey Fitts' Law.
-  bool is_maximized = delegate_->IsMaximized();
+  bool title_bar_condensed = IsTitleBarCondensed();
 
   // When we are the first button on the leading side and are the close
   // button, we must flip ourselves, because the close button assets have
   // a little notch to fit in the rounded frame.
   button->SetDrawImageMirrored(alignment == ALIGN_LEADING &&
                                !has_leading_buttons_ &&
                                button == close_button_);
   // If the window is maximized, align the buttons to its upper edge.
-  int extra_height = is_maximized ? extra_caption_y_ : 0;
+  int extra_height = title_bar_condensed ? extra_caption_y_ : 0;
 
   switch (alignment) {
     case ALIGN_LEADING: {
       if (has_leading_buttons_)
         leading_button_start_ += window_caption_spacing_;
 
       // If we're the first button on the left and maximized, add width to the
       // right hand side of the screen.
-      int extra_width = (is_maximized && !has_leading_buttons_) ?
+      int extra_width = (title_bar_condensed && !has_leading_buttons_) ?
         (kFrameBorderThickness -
          views::NonClientFrameView::kFrameShadowThickness) : 0;
 
       button->SetBounds(
           leading_button_start_,
           caption_y - extra_height,
           button_size.width() + extra_width,
           button_size.height() + extra_height);
 
       leading_button_start_ += extra_width + button_size.width();
       minimum_size_for_buttons_ += extra_width + button_size.width();
       has_leading_buttons_ = true;
       break;
     }
     case ALIGN_TRAILING: {
       if (has_trailing_buttons_)
         trailing_button_start_ += window_caption_spacing_;
 
       // If we're the first button on the right and maximized, add width to the
       // right hand side of the screen.
-      int extra_width = (is_maximized && !has_trailing_buttons_) ?
+      int extra_width = (title_bar_condensed && !has_trailing_buttons_) ?
         (kFrameBorderThickness -
          views::NonClientFrameView::kFrameShadowThickness) : 0;
 
       button->SetBounds(
           host->width() - trailing_button_start_ - extra_width -
               button_size.width(),
           caption_y - extra_height,
           button_size.width() + extra_width,
           button_size.height() + extra_height);
 
@@ skipping 107 matching lines @@
 
 void OpaqueBrowserFrameViewLayout::ViewAdded(views::View* host,
                                              views::View* view) {
   SetView(view->id(), view);
 }
 
 void OpaqueBrowserFrameViewLayout::ViewRemoved(views::View* host,
                                                views::View* view) {
   SetView(view->id(), NULL);
 }