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

ash/frame/custom_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 "ash/frame/custom_frame_view_ash.h"
 
 #include "ash/ash_switches.h"
 #include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
 #include "ash/frame/caption_buttons/frame_maximize_button.h"
 #include "ash/frame/caption_buttons/frame_maximize_button_observer.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/wm/immersive_fullscreen_controller.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_observer.h"
 #include "base/command_line.h"
-#include "base/debug/leak_annotations.h"
-#include "grit/ash_resources.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/font_list.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size.h"
 #include "ui/views/view.h"
-#include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/widget_deletion_observer.h"
 
 namespace {
 
-const gfx::FontList& GetTitleFontList() {
-  static const gfx::FontList* title_font_list =
-      new gfx::FontList(views::NativeWidgetAura::GetWindowTitleFontList());
-  ANNOTATE_LEAKING_OBJECT_PTR(title_font_list);
-  return *title_font_list;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAshWindowStateDelegate
 
 // Handles a user's fullscreen request (Shift+F4/F4). Puts the window into
 // immersive fullscreen if immersive fullscreen is enabled for non-browser
 // windows.
 class CustomFrameViewAshWindowStateDelegate
     : public ash::wm::WindowStateDelegate,
       public ash::wm::WindowStateObserver,
       public aura::WindowObserver {
@@ skipping 100 matching lines @@
   // Returns the view's preferred height.
   int GetPreferredHeight() const;
 
   // Returns the view's minimum width.
   int GetMinimumWidth() const;
 
   // views::View overrides:
   virtual void Layout() OVERRIDE;
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 
-  HeaderPainter* header_painter() {
-    return header_painter_.get();
+  FrameCaptionButtonContainerView* caption_button_container() {
+    return caption_button_container_;
   }
 
  private:
   // ImmersiveFullscreenController::Delegate overrides:
   virtual void OnImmersiveRevealStarted() OVERRIDE;
   virtual void OnImmersiveRevealEnded() OVERRIDE;
   virtual void OnImmersiveFullscreenExited() OVERRIDE;
   virtual void SetVisibleFraction(double visible_fraction) OVERRIDE;
   virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() const OVERRIDE;
 
   // FrameMaximizeButtonObserver overrides:
   virtual void OnMaximizeBubbleShown(views::Widget* bubble) OVERRIDE;
 
   // The widget that the caption buttons act on.
   views::Widget* frame_;
 
   // Helper for painting the header.
-  scoped_ptr<HeaderPainter> header_painter_;
+  scoped_ptr<DefaultHeaderPainter> header_painter_;
 
   // View which contains the window caption buttons.
   FrameCaptionButtonContainerView* caption_button_container_;
 
   // The maximize bubble widget. |maximize_bubble_| may be non-NULL but have
   // been already destroyed.
   views::Widget* maximize_bubble_;
 
   // Keeps track of whether |maximize_bubble_| is still alive.
   scoped_ptr<views::WidgetDeletionObserver> maximize_bubble_lifetime_observer_;
 
   // The fraction of the header's height which is visible while in fullscreen.
   // This value is meaningless when not in fullscreen.
   double fullscreen_visible_fraction_;
 
   DISALLOW_COPY_AND_ASSIGN(HeaderView);
 };
 
 CustomFrameViewAsh::HeaderView::HeaderView(views::Widget* frame)
     : frame_(frame),
-      header_painter_(new ash::HeaderPainter),
+      header_painter_(new ash::DefaultHeaderPainter),
       caption_button_container_(NULL),
       maximize_bubble_(NULL),
       fullscreen_visible_fraction_(0) {
   // Unfortunately, there is no views::WidgetDelegate::CanMinimize(). Assume
   // that the window frame can be minimized if it can be maximized.
   FrameCaptionButtonContainerView::MinimizeAllowed minimize_allowed =
       frame_->widget_delegate()->CanMaximize() ?
           FrameCaptionButtonContainerView::MINIMIZE_ALLOWED :
           FrameCaptionButtonContainerView::MINIMIZE_DISALLOWED;
   caption_button_container_ = new FrameCaptionButtonContainerView(frame_,
       minimize_allowed);
   AddChildView(caption_button_container_);
   FrameMaximizeButton* frame_maximize_button =
       caption_button_container_->GetOldStyleSizeButton();
   if (frame_maximize_button)
     frame_maximize_button->AddObserver(this);
 
-  header_painter_->Init(HeaderPainter::STYLE_OTHER, frame_, this, NULL,
-      caption_button_container_);
+  header_painter_->Init(frame_, this, NULL, caption_button_container_);
 }
 
 CustomFrameViewAsh::HeaderView::~HeaderView() {
   FrameMaximizeButton* frame_maximize_button =
       caption_button_container_->GetOldStyleSizeButton();
   if (frame_maximize_button)
     frame_maximize_button->RemoveObserver(this);
 }
 
 void CustomFrameViewAsh::HeaderView::SchedulePaintForTitle() {
-  header_painter_->SchedulePaintForTitle(GetTitleFontList());
+  header_painter_->SchedulePaintForTitle();
 }
 
 void CustomFrameViewAsh::HeaderView::ResetWindowControls() {
   caption_button_container_->ResetWindowControls();
 }
 
 int CustomFrameViewAsh::HeaderView::GetPreferredOnScreenHeight() const {
   if (frame_->IsFullscreen()) {
     return static_cast<int>(
         GetPreferredHeight() * fullscreen_visible_fraction_);
   }
   return GetPreferredHeight();
 }
 
 int CustomFrameViewAsh::HeaderView::GetPreferredHeight() const {
-  // Reserve enough space to see the buttons and the separator line.
-  return caption_button_container_->bounds().bottom() +
-      header_painter_->HeaderContentSeparatorSize();
+  return header_painter_->GetHeaderHeightForPainting();
 }
 
 int CustomFrameViewAsh::HeaderView::GetMinimumWidth() const {
   return header_painter_->GetMinimumHeaderWidth();
 }
 
 void CustomFrameViewAsh::HeaderView::Layout() {
   header_painter_->LayoutHeader();
-  header_painter_->set_header_height(GetPreferredHeight());
 }
 
 void CustomFrameViewAsh::HeaderView::OnPaint(gfx::Canvas* canvas) {
   bool paint_as_active =
       frame_->non_client_view()->frame_view()->ShouldPaintAsActive();
   caption_button_container_->SetPaintAsActive(paint_as_active);
 
-  int theme_image_id = 0;
-  if (paint_as_active)
-    theme_image_id = IDR_AURA_WINDOW_HEADER_BASE_ACTIVE;
-  else
-    theme_image_id = IDR_AURA_WINDOW_HEADER_BASE_INACTIVE;
-
   HeaderPainter::Mode header_mode = paint_as_active ?
       HeaderPainter::MODE_ACTIVE : HeaderPainter::MODE_INACTIVE;
-  header_painter_->PaintHeader(
-      canvas,
-      header_mode,
-      theme_image_id,
-      0);
-  header_painter_->PaintTitleBar(canvas, GetTitleFontList());
-  header_painter_->PaintHeaderContentSeparator(canvas, header_mode);
+  header_painter_->PaintHeader(canvas, header_mode);
 }
 
 void CustomFrameViewAsh::HeaderView::OnImmersiveRevealStarted() {
   fullscreen_visible_fraction_ = 0;
   SetPaintToLayer(true);
   SetFillsBoundsOpaquely(false);
   parent()->Layout();
 }
 
 void CustomFrameViewAsh::HeaderView::OnImmersiveRevealEnded() {
@@ skipping 119 matching lines @@
 
 void CustomFrameViewAsh::InitImmersiveFullscreenControllerForView(
     ImmersiveFullscreenController* immersive_fullscreen_controller) {
   immersive_fullscreen_controller->Init(header_view_, frame_, header_view_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh, views::NonClientFrameView overrides:
 
 gfx::Rect CustomFrameViewAsh::GetBoundsForClientView() const {
-  int top_height = NonClientTopBorderHeight();
-  return HeaderPainter::GetBoundsForClientView(top_height, bounds());
+  gfx::Rect client_bounds = bounds();
+  client_bounds.Inset(0, NonClientTopBorderHeight(), 0, 0);
+  return client_bounds;
 }
 
 gfx::Rect CustomFrameViewAsh::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
-  int top_height = NonClientTopBorderHeight();
-  return HeaderPainter::GetWindowBoundsForClientBounds(top_height,
-                                                       client_bounds);
+  gfx::Rect window_bounds = client_bounds;
+  window_bounds.Inset(0, -NonClientTopBorderHeight(), 0, 0);
+  return window_bounds;
 }
 
 int CustomFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
   return FrameBorderHitTestController::NonClientHitTest(this,
-      header_view_->header_painter(), point);
+      header_view_->caption_button_container(), point);
 }
 
 void CustomFrameViewAsh::GetWindowMask(const gfx::Size& size,
                                        gfx::Path* window_mask) {
   // No window masks in Aura.
 }
 
 void CustomFrameViewAsh::ResetWindowControls() {
   header_view_->ResetWindowControls();
 }
@@ skipping 63 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh, private:
 
 int CustomFrameViewAsh::NonClientTopBorderHeight() const {
   return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
 }
 
 }  // namespace ash