Enable immersive fullscreen for hosted apps part 2

chrome/browser/ui/views/frame/browser_non_client_frame_view_ash.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/browser_non_client_frame_view_ash.h"
 
 #include "ash/ash_switches.h"
 #include "ash/wm/caption_buttons/frame_caption_button_container_view.h"
 #include "ash/wm/frame_border_hit_test_controller.h"
 #include "ash/wm/header_painter.h"
@@ skipping 141 matching lines @@
 
 void BrowserNonClientFrameViewAsh::UpdateThrobber(bool running) {
   if (window_icon_)
     window_icon_->Update();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // views::NonClientFrameView overrides:
 
 gfx::Rect BrowserNonClientFrameViewAsh::GetBoundsForClientView() const {
-  int top_height = NonClientTopBorderHeight();
-  return ash::HeaderPainter::GetBoundsForClientView(top_height, bounds());
+  // The ClientView must be flush with the top edge of the widget so that the
+  // web contents can take up the entire screen in immersive fullscreen (with
+  // or without the top-of-window views revealed). When in immersive fullscreen
+  // and the top-of-window views are revealed, the TopContainerView paints the
+  // window header by redirecting paints from its background to
+  // BrowserNonClientFrameViewAsh.
+  return ash::HeaderPainter::GetBoundsForClientView(0, bounds());
 }
 
 gfx::Rect BrowserNonClientFrameViewAsh::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
-  int top_height = NonClientTopBorderHeight();
-  return ash::HeaderPainter::GetWindowBoundsForClientBounds(top_height,
-                                                            client_bounds);
+  return ash::HeaderPainter::GetWindowBoundsForClientBounds(0, client_bounds);
 }
 
 int BrowserNonClientFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
   int hit_test = ash::FrameBorderHitTestController::NonClientHitTest(this,
       header_painter_.get(), point);
 
   // See if the point is actually within the avatar menu button or within
   // the avatar label.
   if (hit_test == HTCAPTION && ((avatar_button() &&
        avatar_button()->GetMirroredBounds().Contains(point)) ||
@@ skipping 76 matching lines @@
       theme_frame_overlay_image_id);
   if (browser_view()->ShouldShowWindowTitle())
     header_painter_->PaintTitleBar(canvas, BrowserFrame::GetTitleFont());
   if (browser_view()->IsToolbarVisible())
     PaintToolbarBackground(canvas);
   else
     PaintContentEdge(canvas);
 }
 
 void BrowserNonClientFrameViewAsh::Layout() {
-  header_painter_->LayoutHeader(UseShortHeader());
   int header_height = 0;
   if (browser_view()->IsTabStripVisible()) {
     header_height = GetTopInset() +
         browser_view()->GetTabStripHeight();
   } else if (browser_view()->IsToolbarVisible()) {
     // Set the header's height so that it overlaps with the toolbar because the
     // top few pixels of the toolbar are not opaque.
-    gfx::Point toolbar_origin(browser_view()->GetToolbarBounds().origin());
-    View::ConvertPointToTarget(browser_view(), this, &toolbar_origin);
-    header_height = toolbar_origin.y() + kFrameShadowThickness * 2;
+    header_height = GetTopInset() + kFrameShadowThickness * 2;
   } else {
-    header_height = NonClientTopBorderHeight();
+    header_height = GetTopInset();
   }
   header_painter_->set_header_height(header_height);
+  header_painter_->LayoutHeader(UseShortHeader());
   if (avatar_button())
     LayoutAvatar();
   BrowserNonClientFrameView::Layout();
 }
 
 const char* BrowserNonClientFrameViewAsh::GetClassName() const {
   return kViewClassName;
 }
 
 bool BrowserNonClientFrameViewAsh::HitTestRect(const gfx::Rect& rect) const {
   if (!views::View::HitTestRect(rect)) {
     // |rect| is outside BrowserNonClientFrameViewAsh's bounds.
     return false;
   }
-  // If the rect is outside the bounds of the client area, claim it.
-  gfx::RectF rect_in_client_view_coords_f(rect);
-  View::ConvertRectToTarget(this, frame()->client_view(),
-      &rect_in_client_view_coords_f);
-  gfx::Rect rect_in_client_view_coords = gfx::ToEnclosingRect(
-      rect_in_client_view_coords_f);
-  if (!frame()->client_view()->HitTestRect(rect_in_client_view_coords))
-    return true;
 
-  // Otherwise, claim |rect| only if it is above the bottom of the tabstrip in
-  // a non-tab portion.
   TabStrip* tabstrip = browser_view()->tabstrip();
-  if (!tabstrip || !browser_view()->IsTabStripVisible())
-    return false;
+  if (tabstrip && browser_view()->IsTabStripVisible()) {
+    // Claim |rect| only if it is above the bottom of the tabstrip in a non-tab
+    // portion.
+    gfx::RectF rect_in_tabstrip_coords_f(rect);
+    View::ConvertRectToTarget(this, tabstrip, &rect_in_tabstrip_coords_f);
+    gfx::Rect rect_in_tabstrip_coords = gfx::ToEnclosingRect(
+        rect_in_tabstrip_coords_f);
 
-  gfx::RectF rect_in_tabstrip_coords_f(rect);
-  View::ConvertRectToTarget(this, tabstrip, &rect_in_tabstrip_coords_f);
-  gfx::Rect rect_in_tabstrip_coords = gfx::ToEnclosingRect(
-      rect_in_tabstrip_coords_f);
+     if (rect_in_tabstrip_coords.y() > tabstrip->height())
+       return false;
 
-  if (rect_in_tabstrip_coords.y() > tabstrip->GetLocalBounds().bottom()) {
-    // |rect| is below the tabstrip.
-    return false;
+    return !tabstrip->HitTestRect(rect_in_tabstrip_coords) ||
+        tabstrip->IsRectInWindowCaption(rect_in_tabstrip_coords);
   }
 
-  if (tabstrip->HitTestRect(rect_in_tabstrip_coords)) {
-    // Claim |rect| if it is in a non-tab portion of the tabstrip.
-    return tabstrip->IsRectInWindowCaption(rect_in_tabstrip_coords);
-  }
-
-  // We claim |rect| because it is above the bottom of the tabstrip, but
-  // not in the tabstrip. In particular, the window controls are right of
-  // the tabstrip.
-  return true;
+  // Claim |rect| if it is above the top of the topmost view in the client area.
+  return rect.y() < GetTopInset();
 }
 
 void BrowserNonClientFrameViewAsh::GetAccessibleState(
     ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_TITLEBAR;
 }
 
 gfx::Size BrowserNonClientFrameViewAsh::GetMinimumSize() {
   gfx::Size min_client_view_size(frame()->client_view()->GetMinimumSize());
   int min_width = std::max(header_painter_->GetMinimumHeaderWidth(),
                            min_client_view_size.width());
   if (browser_view()->IsTabStripVisible()) {
     // Ensure that the minimum width is enough to hold a minimum width tab strip
     // at its usual insets.
     int min_tabstrip_width =
         browser_view()->tabstrip()->GetMinimumSize().width();
     min_width = std::max(min_width,
         min_tabstrip_width + GetTabStripLeftInset() + GetTabStripRightInset());
   }
-  return gfx::Size(min_width,
-      NonClientTopBorderHeight() + min_client_view_size.height());
+  return gfx::Size(min_width, min_client_view_size.height());
 }
 
 void BrowserNonClientFrameViewAsh::OnThemeChanged() {
   BrowserNonClientFrameView::OnThemeChanged();
   header_painter_->OnThemeChanged();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // chrome::TabIconViewModel overrides:
 
@@ skipping 18 matching lines @@
 int BrowserNonClientFrameViewAsh::GetTabStripLeftInset() const {
   return avatar_button() ? kAvatarSideSpacing +
       browser_view()->GetOTRAvatarIcon().width() + kAvatarSideSpacing :
       kTabstripLeftSpacing;
 }
 
 int BrowserNonClientFrameViewAsh::GetTabStripRightInset() const {
   return header_painter_->GetRightInset() + kTabstripRightSpacing;
 }
 
-int BrowserNonClientFrameViewAsh::NonClientTopBorderHeight() const {
-  if (!ShouldPaint() || browser_view()->IsTabStripVisible())
-    return 0;
-
-  int caption_buttons_bottom = caption_button_container_->bounds().bottom();
-  if (browser_view()->IsToolbarVisible())
-    return caption_buttons_bottom - kContentShadowHeight;
-  return caption_buttons_bottom + kClientEdgeThickness;
-}
-
 bool BrowserNonClientFrameViewAsh::UseShortHeader() const {
   // Restored tabbed browser windows use the tall header. All other windows use
   // the short header.
   return frame()->IsMaximized() ||
          frame()->IsFullscreen() ||
          !browser_view()->IsBrowserTypeNormal();
 }
 
 bool BrowserNonClientFrameViewAsh::UseImmersiveLightbarHeaderStyle() const {
   ImmersiveModeController* immersive_controller =
@@ skipping 28 matching lines @@
   avatar_button()->SetVisible(avatar_visible);
 }
 
 bool BrowserNonClientFrameViewAsh::ShouldPaint() const {
   if (!frame()->IsFullscreen())
     return true;
 
   // We need to paint when in immersive fullscreen and either:
   // - The top-of-window views are revealed.
   // - The lightbar style tabstrip is visible.
-  // Because immersive fullscreen is only supported for tabbed browser windows,
-  // checking whether the tab strip is visible is sufficient.
-  return browser_view()->IsTabStripVisible();
+  ImmersiveModeController* immersive_mode_controller =
+      browser_view()->immersive_mode_controller();
+  return immersive_mode_controller->IsEnabled() &&
+      (immersive_mode_controller->IsRevealed() ||
+       UseImmersiveLightbarHeaderStyle());
 }
 
 void BrowserNonClientFrameViewAsh::PaintImmersiveLightbarStyleHeader(
     gfx::Canvas* canvas) {
   // The light bar header is not themed because theming it does not look good.
   gfx::ImageSkia* frame_image = GetThemeProvider()->GetImageSkiaNamed(
       IDR_AURA_WINDOW_HEADER_BASE_MINIMAL);
   canvas->TileImageInt(*frame_image, 0, 0, width(), frame_image->height());
 }
 
@@ skipping 103 matching lines @@
 int BrowserNonClientFrameViewAsh::GetThemeFrameOverlayImageId() const {
   ui::ThemeProvider* tp = GetThemeProvider();
   if (tp->HasCustomImage(IDR_THEME_FRAME_OVERLAY) &&
       browser_view()->IsBrowserTypeNormal() &&
       !browser_view()->IsOffTheRecord()) {
     return ShouldPaintAsActive() ?
         IDR_THEME_FRAME_OVERLAY : IDR_THEME_FRAME_OVERLAY_INACTIVE;
   }
   return 0;
 }