ChromeCanvas->gfx::Canvas

chrome/browser/views/frame/opaque_browser_frame_view.cc

 // Copyright (c) 2006-2008 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/views/frame/opaque_browser_frame_view.h"
 
-#include "app/gfx/chrome_canvas.h"
-#include "app/gfx/chrome_font.h"
+#include "app/gfx/canvas.h"
+#include "app/gfx/font.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/theme_provider.h"
 #include "app/win_util.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/views/frame/browser_frame.h"
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/tabs/tab_strip.h"
 #include "grit/chromium_strings.h"
@@ skipping 287 matching lines @@
 void OpaqueBrowserFrameView::ResetWindowControls() {
   restore_button_->SetState(views::CustomButton::BS_NORMAL);
   minimize_button_->SetState(views::CustomButton::BS_NORMAL);
   maximize_button_->SetState(views::CustomButton::BS_NORMAL);
   // The close button isn't affected by this constraint.
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, views::View overrides:
 
-void OpaqueBrowserFrameView::Paint(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::Paint(gfx::Canvas* canvas) {
   if (frame_->IsFullscreen())
     return;  // Nothing is visible, so don't bother to paint.
 
   if (frame_->IsMaximized())
     PaintMaximizedFrameBorder(canvas);
   else
     PaintRestoredFrameBorder(canvas);
   PaintDistributorLogo(canvas);
   PaintTitleBar(canvas);
   PaintToolbarBackground(canvas);
@@ skipping 172 matching lines @@
   if (available_height_ptr)
     *available_height_ptr = available_height;
 
   // The icon takes up a constant fraction of the available height, down to a
   // minimum size, and is always an even number of pixels on a side (presumably
   // to make scaled icons look better).  It's centered within the usable height.
   return std::max((available_height * kIconHeightFractionNumerator /
       kIconHeightFractionDenominator) / 2 * 2, kIconMinimumSize);
 }
 
-void OpaqueBrowserFrameView::PaintRestoredFrameBorder(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::PaintRestoredFrameBorder(gfx::Canvas* canvas) {
   ThemeProvider* tp = GetThemeProvider();
 
   SkBitmap* top_left_corner = tp->GetBitmapNamed(IDR_WINDOW_TOP_LEFT_CORNER);
   SkBitmap* top_right_corner =
       tp->GetBitmapNamed(IDR_WINDOW_TOP_RIGHT_CORNER);
   SkBitmap* top_edge = tp->GetBitmapNamed(IDR_WINDOW_TOP_CENTER);
   SkBitmap* right_edge = tp->GetBitmapNamed(IDR_WINDOW_RIGHT_SIDE);
   SkBitmap* left_edge = tp->GetBitmapNamed(IDR_WINDOW_LEFT_SIDE);
   SkBitmap* bottom_left_corner =
       tp->GetBitmapNamed(IDR_WINDOW_BOTTOM_LEFT_CORNER);
@@ skipping 76 matching lines @@
                        bottom_edge->height());
   canvas->DrawBitmapInt(*bottom_left_corner, 0,
                         height() - bottom_left_corner->height());
 
   // Left.
   canvas->TileImageInt(*left_edge, 0, top_left_height, left_edge->width(),
       height() - top_left_height - bottom_left_corner->height());
 }
 
 
-void OpaqueBrowserFrameView::PaintMaximizedFrameBorder(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::PaintMaximizedFrameBorder(gfx::Canvas* canvas) {
   ThemeProvider* tp = GetThemeProvider();
   // Window frame mode and color
   SkBitmap* theme_frame;
   if (!browser_view_->IsOffTheRecord()) {
     theme_frame = frame_->IsActive() ?
         tp->GetBitmapNamed(IDR_THEME_FRAME) :
         tp->GetBitmapNamed(IDR_THEME_FRAME_INACTIVE);
   } else {
     theme_frame = frame_->IsActive() ?
         tp->GetBitmapNamed(IDR_THEME_FRAME_INCOGNITO) :
         tp->GetBitmapNamed(IDR_THEME_FRAME_INCOGNITO_INACTIVE);
   }
 
   // Draw the theme frame.
   canvas->TileImageInt(*theme_frame, 0, 0, width(), theme_frame->height());
 
   if (!browser_view_->IsToolbarVisible()) {
     // There's no toolbar to edge the frame border, so we need to draw a bottom
     // edge.  The graphic we use for this has a built in client edge, so we clip
     // it off the bottom.
     SkBitmap* top_center =
         tp->GetBitmapNamed(IDR_APP_TOP_CENTER);
     int edge_height = top_center->height() - kClientEdgeThickness;
     canvas->TileImageInt(*top_center, 0,
         frame_->GetClientView()->y() - edge_height, width(), edge_height);
   }
 }
 
-void OpaqueBrowserFrameView::PaintDistributorLogo(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::PaintDistributorLogo(gfx::Canvas* canvas) {
   // The distributor logo is only painted when the frame is not maximized and
   // when we actually have a logo.
   if (!frame_->IsMaximized() && distributor_logo_ &&
       browser_view_->ShouldShowDistributorLogo()) {
     canvas->DrawBitmapInt(*distributor_logo_,
         MirroredLeftPointForRect(logo_bounds_), logo_bounds_.y());
   }
 }
 
-void OpaqueBrowserFrameView::PaintTitleBar(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::PaintTitleBar(gfx::Canvas* canvas) {
   // The window icon is painted by the TabIconView.
   views::WindowDelegate* d = frame_->GetDelegate();
   if (d->ShouldShowWindowTitle()) {
     canvas->DrawStringInt(d->GetWindowTitle(), *title_font_, SK_ColorWHITE,
         MirroredLeftPointForRect(title_bounds_), title_bounds_.y(),
         title_bounds_.width(), title_bounds_.height());
     /* TODO(pkasting):  If this window is active, we should also draw a drop
      * shadow on the title.  This is tricky, because we don't want to hardcode a
      * shadow color (since we want to work with various themes), but we can't
      * alpha-blend either (since the Windows text APIs don't really do this).
      * So we'd need to sample the background color at the right location and
      * synthesize a good shadow color. */
   }
 }
 
-void OpaqueBrowserFrameView::PaintToolbarBackground(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::PaintToolbarBackground(gfx::Canvas* canvas) {
   if (!browser_view_->IsToolbarVisible())
     return;
 
   ThemeProvider* tp = GetThemeProvider();
   gfx::Rect toolbar_bounds(browser_view_->GetToolbarBounds());
   gfx::Point toolbar_origin(toolbar_bounds.origin());
   View::ConvertPointToView(frame_->GetClientView(), this, &toolbar_origin);
   toolbar_bounds.set_origin(toolbar_origin);
 
   int strip_height = browser_view_->GetTabStripHeight();
@@ skipping 37 matching lines @@
   SkBitmap* toolbar_right = tp->GetBitmapNamed(IDR_CONTENT_TOP_RIGHT_CORNER);
   canvas->DrawBitmapInt(*toolbar_right, 0, 0, toolbar_right->width(),
       split_point, toolbar_bounds.right(), toolbar_bounds.y(),
       toolbar_right->width(), split_point, false);
   canvas->DrawBitmapInt(*toolbar_right, 0,
       toolbar_right->height() - bottom_edge_height, toolbar_right->width(),
       bottom_edge_height, toolbar_bounds.right(), bottom_y,
       toolbar_right->width(), bottom_edge_height, false);
 }
 
-void OpaqueBrowserFrameView::PaintOTRAvatar(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::PaintOTRAvatar(gfx::Canvas* canvas) {
   if (!browser_view_->ShouldShowOffTheRecordAvatar())
     return;
 
   SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
   canvas->DrawBitmapInt(otr_avatar_icon, 0,
       (otr_avatar_icon.height() - otr_avatar_bounds_.height()) / 2,
       otr_avatar_bounds_.width(), otr_avatar_bounds_.height(),
       MirroredLeftPointForRect(otr_avatar_bounds_), otr_avatar_bounds_.y(),
       otr_avatar_bounds_.width(), otr_avatar_bounds_.height(), false);
 }
 
-void OpaqueBrowserFrameView::PaintRestoredClientEdge(ChromeCanvas* canvas) {
+void OpaqueBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   ThemeProvider* tp = GetThemeProvider();
   int client_area_top = frame_->GetClientView()->y();
 
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
   if (browser_view_->IsToolbarVisible()) {
     // The client edges start below the toolbar or its corner images, whichever
     // is shorter.
     gfx::Rect toolbar_bounds(browser_view_->GetToolbarBounds());
     client_area_top += browser_view_->GetToolbarBounds().y() +
         std::min(tp->GetBitmapNamed(IDR_CONTENT_TOP_LEFT_CORNER)->height(),
@@ skipping 203 matching lines @@
 }
 
 // static
 void OpaqueBrowserFrameView::InitAppWindowResources() {
   static bool initialized = false;
   if (!initialized) {
     title_font_ = new gfx::Font(win_util::GetWindowTitleFont());
     initialized = true;
   }
 }