[Refactor] Move code for painting the window header for browser windows out of ash

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/frame/caption_buttons/frame_caption_button_container_view.h"
+#include "ash/frame/default_header_painter.h"
 #include "ash/frame/frame_border_hit_test_controller.h"
-#include "ash/frame/header_painter.h"
+#include "ash/frame/header_painter_util.h"
 #include "base/command_line.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/views/avatar_label.h"
 #include "chrome/browser/ui/views/avatar_menu_button.h"
 #include "chrome/browser/ui/views/frame/browser_frame.h"
+#include "chrome/browser/ui/views/frame/browser_header_painter_ash.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
 #include "chrome/browser/ui/views/tab_icon_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/ash_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 45 matching lines @@
 
 // static
 const char BrowserNonClientFrameViewAsh::kViewClassName[] =
     "BrowserNonClientFrameViewAsh";
 
 BrowserNonClientFrameViewAsh::BrowserNonClientFrameViewAsh(
     BrowserFrame* frame, BrowserView* browser_view)
     : BrowserNonClientFrameView(frame, browser_view),
       caption_button_container_(NULL),
       window_icon_(NULL),
-      header_painter_(new ash::HeaderPainter),
       frame_border_hit_test_controller_(
           new ash::FrameBorderHitTestController(frame)) {
 }
 
 BrowserNonClientFrameViewAsh::~BrowserNonClientFrameViewAsh() {
 }
 
 void BrowserNonClientFrameViewAsh::Init() {
   caption_button_container_ = new ash::FrameCaptionButtonContainerView(frame(),
       ash::FrameCaptionButtonContainerView::MINIMIZE_ALLOWED);
   AddChildView(caption_button_container_);
 
   // Initializing the TabIconView is expensive, so only do it if we need to.
   if (browser_view()->ShouldShowWindowIcon()) {
     window_icon_ = new TabIconView(this, NULL);
     window_icon_->set_is_light(true);
     AddChildView(window_icon_);
     window_icon_->Update();
   }
 
   // Create incognito icon if necessary.
   UpdateAvatarInfo();
 
   // HeaderPainter handles layout.
-  ash::HeaderPainter::Style header_style = UsePackagedAppHeaderStyle() ?
-      ash::HeaderPainter::STYLE_OTHER : ash::HeaderPainter::STYLE_BROWSER;
-  header_painter_->Init(header_style, frame(), this, window_icon_,
-      caption_button_container_);
+  if (UsePackagedAppHeaderStyle()) {
+    ash::DefaultHeaderPainter* header_painter = new ash::DefaultHeaderPainter;
+    header_painter_.reset(header_painter);
+    header_painter->Init(frame(), this, window_icon_,
+        caption_button_container_);
+  } else {
+    BrowserHeaderPainterAsh* header_painter = new BrowserHeaderPainterAsh;
+    header_painter_.reset(header_painter);
+    header_painter->Init(frame(), browser_view(), this, window_icon_,
+        caption_button_container_);
+  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserNonClientFrameView overrides:
 
 gfx::Rect BrowserNonClientFrameViewAsh::GetBoundsForTabStrip(
     views::View* tabstrip) const {
   if (!tabstrip)
     return gfx::Rect();
 
@@ skipping 14 matching lines @@
   if (!ShouldPaint() || UseImmersiveLightbarHeaderStyle())
     return 0;
 
   if (browser_view()->IsTabStripVisible()) {
     if (frame()->IsMaximized() || frame()->IsFullscreen())
       return kTabstripTopSpacingShort;
     else
       return kTabstripTopSpacingTall;
   }
 
+  if (UsePackagedAppHeaderStyle())
+    return header_painter_->GetHeaderHeightForPainting();
+
   int caption_buttons_bottom = caption_button_container_->bounds().bottom();
 
   // The toolbar partially overlaps the caption buttons.
   if (browser_view()->IsToolbarVisible())
     return caption_buttons_bottom - kContentShadowHeight;
 
-  int separator_thickness = UsePackagedAppHeaderStyle() ?
-      header_painter_->HeaderContentSeparatorSize() : kClientEdgeThickness;
-  return caption_buttons_bottom + separator_thickness;
+  return caption_buttons_bottom + kClientEdgeThickness;
 }
 
 int BrowserNonClientFrameViewAsh::GetThemeBackgroundXInset() const {
-  return header_painter_->GetThemeBackgroundXInset();
+  return ash::HeaderPainterUtil::GetThemeBackgroundXInset();
 }
 
 void BrowserNonClientFrameViewAsh::UpdateThrobber(bool running) {
   if (window_icon_)
     window_icon_->Update();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // views::NonClientFrameView overrides:
 
 gfx::Rect BrowserNonClientFrameViewAsh::GetBoundsForClientView() const {
   // 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());
+  return bounds();
 }
 
 gfx::Rect BrowserNonClientFrameViewAsh::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
-  return ash::HeaderPainter::GetWindowBoundsForClientBounds(0, client_bounds);
+  return client_bounds;
 }
 
 int BrowserNonClientFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
   int hit_test = ash::FrameBorderHitTestController::NonClientHitTest(this,
-      header_painter_.get(), point);
+      caption_button_container_, 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)) ||
       (avatar_label() && avatar_label()->GetMirroredBounds().Contains(point))))
       return HTCLIENT;
 
   // When the window is restored we want a large click target above the tabs
   // to drag the window, so redirect clicks in the tab's shadow to caption.
@@ skipping 25 matching lines @@
   caption_button_container_->ResetWindowControls();
 }
 
 void BrowserNonClientFrameViewAsh::UpdateWindowIcon() {
   if (window_icon_)
     window_icon_->SchedulePaint();
 }
 
 void BrowserNonClientFrameViewAsh::UpdateWindowTitle() {
   if (!frame()->IsFullscreen())
-    header_painter_->SchedulePaintForTitle(BrowserFrame::GetTitleFontList());
+    header_painter_->SchedulePaintForTitle();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // views::View overrides:
 
 void BrowserNonClientFrameViewAsh::OnPaint(gfx::Canvas* canvas) {
   if (!ShouldPaint())
     return;
 
   if (UseImmersiveLightbarHeaderStyle()) {
     PaintImmersiveLightbarStyleHeader(canvas);
     return;
   }
 
   caption_button_container_->SetPaintAsActive(ShouldPaintAsActive());
 
-  // The primary header image changes based on window activation state and
-  // theme, so we look it up for each paint.
-  int theme_frame_image_id = 0;
-  int theme_frame_overlay_image_id = 0;
-  if (browser_view()->IsTabStripVisible()) {
-    GetFrameImageIdsForTabbedBrowser(&theme_frame_image_id,
-                                     &theme_frame_overlay_image_id);
-  } else if (browser_view()->browser()->is_app()) {
-    theme_frame_image_id = GetFrameImageIdForHostedApp();
-  } else {
-    theme_frame_image_id = GetFrameImageIdForBrowserPopup();
-  }
-
   ash::HeaderPainter::Mode header_mode = ShouldPaintAsActive() ?
       ash::HeaderPainter::MODE_ACTIVE : ash::HeaderPainter::MODE_INACTIVE;
-  header_painter_->PaintHeader(
-      canvas,
-      header_mode,
-      theme_frame_image_id,
-      theme_frame_overlay_image_id);
-  if (browser_view()->ShouldShowWindowTitle())
-    header_painter_->PaintTitleBar(canvas, BrowserFrame::GetTitleFontList());
+  header_painter_->PaintHeader(canvas, header_mode);
   if (browser_view()->IsToolbarVisible())
     PaintToolbarBackground(canvas);
-  else
+  else if (!UsePackagedAppHeaderStyle())
     PaintContentEdge(canvas);
 }
 
 void BrowserNonClientFrameViewAsh::Layout() {
-  // The header must be laid out before computing |header_height| because the
-  // computation of |header_height| for app and popup windows depends on the
+  // The header must be laid out before computing |painted_height| because the
+  // computation of |painted_height| for app and popup windows depends on the
   // position of the window controls.
   header_painter_->LayoutHeader();
 
-  int header_height = 0;
+  int painted_height = 0;
   if (browser_view()->IsTabStripVisible()) {
-    header_height = GetTopInset() +
+    painted_height = GetTopInset() +
         browser_view()->tabstrip()->GetPreferredSize().height();
   } 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.
-    header_height = GetTopInset() + kFrameShadowThickness * 2;
+    // Paint the header so that it overlaps with the top few pixels of the
+    // toolbar because the top few pixels of the toolbar are not opaque.
+    painted_height = GetTopInset() + kFrameShadowThickness * 2;
   } else {
-    header_height = GetTopInset();
+    painted_height = GetTopInset();
   }
-  header_painter_->set_header_height(header_height);
+  header_painter_->SetHeaderHeightForPainting(painted_height);
   if (avatar_button())
     LayoutAvatar();
   BrowserNonClientFrameView::Layout();
 }
 
 const char* BrowserNonClientFrameViewAsh::GetClassName() const {
   return kViewClassName;
 }
 
 bool BrowserNonClientFrameViewAsh::HitTestRect(const gfx::Rect& rect) const {
@@ skipping 35 matching lines @@
     // 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, min_client_view_size.height());
 }
 
-void BrowserNonClientFrameViewAsh::OnThemeChanged() {
-  BrowserNonClientFrameView::OnThemeChanged();
-  header_painter_->OnThemeChanged();
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // chrome::TabIconViewModel overrides:
 
 bool BrowserNonClientFrameViewAsh::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
   // WebContents because in this condition there is not yet a selected tab.
   content::WebContents* current_tab = browser_view()->GetActiveWebContents();
   return current_tab ? current_tab->IsLoading() : false;
 }
 
 gfx::ImageSkia BrowserNonClientFrameViewAsh::GetFaviconForTabIconView() {
   views::WidgetDelegate* delegate = frame()->widget_delegate();
   if (!delegate)
     return gfx::ImageSkia();
   return delegate->GetWindowIcon();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserNonClientFrameViewAsh, private:
 
 int BrowserNonClientFrameViewAsh::GetTabStripLeftInset() const {
   return avatar_button() ? kAvatarSideSpacing +
       browser_view()->GetOTRAvatarIcon().width() + kAvatarSideSpacing :
       kTabstripLeftSpacing;
 }
 
 int BrowserNonClientFrameViewAsh::GetTabStripRightInset() const {
-  return header_painter_->GetRightInset() + kTabstripRightSpacing;
+  return caption_button_container_->GetPreferredSize().width() +
+      kTabstripRightSpacing;
 }
 
 bool BrowserNonClientFrameViewAsh::UseImmersiveLightbarHeaderStyle() const {
   ImmersiveModeController* immersive_controller =
       browser_view()->immersive_mode_controller();
   return immersive_controller->IsEnabled() &&
       !immersive_controller->IsRevealed() &&
       browser_view()->IsTabStripVisible();
 }
 
@@ skipping 121 matching lines @@
   canvas->FillRect(
       gfx::Rect(x + kClientEdgeThickness,
                 toolbar_bounds.bottom() - kClientEdgeThickness,
                 w - (2 * kClientEdgeThickness),
                 kClientEdgeThickness),
       ThemeProperties::GetDefaultColor(
           ThemeProperties::COLOR_TOOLBAR_SEPARATOR));
 }
 
 void BrowserNonClientFrameViewAsh::PaintContentEdge(gfx::Canvas* canvas) {
-  if (UsePackagedAppHeaderStyle()) {
-    ash::HeaderPainter::Mode header_mode = ShouldPaintAsActive() ?
-        ash::HeaderPainter::MODE_ACTIVE : ash::HeaderPainter::MODE_INACTIVE;
-    header_painter_->PaintHeaderContentSeparator(canvas, header_mode);
-  } else {
-    canvas->FillRect(gfx::Rect(0, caption_button_container_->bounds().bottom(),
-                               width(), kClientEdgeThickness),
-        ThemeProperties::GetDefaultColor(
-            ThemeProperties::COLOR_TOOLBAR_SEPARATOR));
-  }
+  DCHECK(!UsePackagedAppHeaderStyle());
+  canvas->FillRect(gfx::Rect(0, caption_button_container_->bounds().bottom(),
+                             width(), kClientEdgeThickness),
+                   ThemeProperties::GetDefaultColor(
+                       ThemeProperties::COLOR_TOOLBAR_SEPARATOR));
 }
-
-void BrowserNonClientFrameViewAsh::GetFrameImageIdsForTabbedBrowser(
-    int* frame_image_id,
-    int* frame_overlay_image_id) const {
-  *frame_overlay_image_id = 0;
-
-  bool is_incognito = !browser_view()->IsRegularOrGuestSession();
-  ui::ThemeProvider* tp = GetThemeProvider();
-  if (tp->HasCustomImage(IDR_THEME_FRAME_OVERLAY) &&
-      !is_incognito) {
-    *frame_overlay_image_id = ShouldPaintAsActive() ?
-        IDR_THEME_FRAME_OVERLAY : IDR_THEME_FRAME_OVERLAY_INACTIVE;
-  }
-
-  if (ShouldPaintAsActive()) {
-    *frame_image_id = is_incognito ?
-        IDR_THEME_FRAME_INCOGNITO : IDR_THEME_FRAME;
-  } else {
-    *frame_image_id = is_incognito ?
-        IDR_THEME_FRAME_INCOGNITO_INACTIVE : IDR_THEME_FRAME_INACTIVE;
-  }
-
-  if ((frame()->IsMaximized() || frame()->IsFullscreen()) &&
-      !tp->HasCustomImage(IDR_THEME_FRAME) &&
-      !tp->HasCustomImage(*frame_image_id) &&
-      *frame_overlay_image_id == 0) {
-    *frame_image_id = IDR_AURA_BROWSER_WINDOW_HEADER_BASE_MAXIMIZED;
-  }
-}
-
-int BrowserNonClientFrameViewAsh::GetFrameImageIdForBrowserPopup() const {
-  // Browser popups are not themeable.
-  if (frame()->IsMaximized() || frame()->IsFullscreen())
-    return IDR_AURA_BROWSER_WINDOW_HEADER_BASE_MAXIMIZED;
-
-  bool is_incognito = !browser_view()->IsRegularOrGuestSession();
-  if (ShouldPaintAsActive()) {
-    return is_incognito ?
-        IDR_AURA_BROWSER_WINDOW_HEADER_BASE_RESTORED_INCOGNITO_ACTIVE :
-        IDR_AURA_BROWSER_WINDOW_HEADER_BASE_RESTORED_ACTIVE;
-  }
-  return is_incognito ?
-      IDR_AURA_BROWSER_WINDOW_HEADER_BASE_RESTORED_INCOGNITO_INACTIVE :
-      IDR_AURA_BROWSER_WINDOW_HEADER_BASE_RESTORED_INACTIVE;
-}
-
-int BrowserNonClientFrameViewAsh::GetFrameImageIdForHostedApp() const {
-  if (UsePackagedAppHeaderStyle()) {
-    return ShouldPaintAsActive() ?
-        IDR_AURA_WINDOW_HEADER_BASE_ACTIVE :
-        IDR_AURA_WINDOW_HEADER_BASE_INACTIVE;
-  }
-  return GetFrameImageIdForBrowserPopup();
-}