ChromeCanvas->gfx::Canvas

chrome/browser/views/tabs/tab_renderer.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/tabs/tab_renderer.h"
 
 #include <limits>
 
-#include "app/gfx/chrome_canvas.h"
-#include "app/gfx/chrome_font.h"
+#include "app/gfx/canvas.h"
+#include "app/gfx/font.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/win_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
@@ skipping 339 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // TabRenderer, protected:
 
 std::wstring TabRenderer::GetTitle() const {
   return data_.title;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabRenderer, views::View overrides:
 
-void TabRenderer::Paint(ChromeCanvas* canvas) {
+void TabRenderer::Paint(gfx::Canvas* canvas) {
   // Don't paint if we're narrower than we can render correctly. (This should
   // only happen during animations).
   if (width() < GetMinimumUnselectedSize().width())
     return;
 
   // See if the model changes whether the icons should be painted.
   const bool show_icon = ShouldShowIcon();
   const bool show_download_icon = data_.show_download_icon;
   const bool show_close_button = ShouldShowCloseBox();
   if (show_icon != showing_icon_ ||
@@ skipping 167 matching lines @@
   AnimationEnded(animation);
 }
 
 void TabRenderer::AnimationEnded(const Animation* animation) {
   SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabRenderer, private
 
-void TabRenderer::PaintTabBackground(ChromeCanvas* canvas) {
+void TabRenderer::PaintTabBackground(gfx::Canvas* canvas) {
   if (IsSelected()) {
     // Sometimes detaching a tab quickly can result in the model reporting it
     // as not being selected, so is_drag_clone_ ensures that we always paint
     // the active representation for the dragged tab.
     PaintActiveTabBackground(canvas);
   } else {
     // Draw our hover state.
     Animation* animation = hover_animation_.get();
     if (pulse_animation_->IsAnimating())
       animation = pulse_animation_.get();
 
     PaintInactiveTabBackground(canvas);
     if (animation->GetCurrentValue() > 0) {
       SkRect bounds;
       bounds.set(0, 0, SkIntToScalar(width()), SkIntToScalar(height()));
       canvas->saveLayerAlpha(&bounds,
           static_cast<int>(animation->GetCurrentValue() * kHoverOpacity * 0xff),
               SkCanvas::kARGB_ClipLayer_SaveFlag);
       canvas->drawARGB(0, 255, 255, 255, SkPorterDuff::kClear_Mode);
       PaintActiveTabBackground(canvas);
       canvas->restore();
     }
   }
 }
 
-void TabRenderer::PaintInactiveTabBackground(ChromeCanvas* canvas) {
+void TabRenderer::PaintInactiveTabBackground(gfx::Canvas* canvas) {
   bool is_otr = data_.off_the_record;
 
   // The tab image needs to be lined up with the background image
   // so that it feels partially transparent.
   int offset = GetX(views::View::APPLY_MIRRORING_TRANSFORMATION) + 1;
   int offset_y = 20;
 
   int tab_id;
   if (GetWidget() &&
       GetWidget()->GetWindow()->GetNonClientView()->UseNativeFrame()) {
@@ skipping 36 matching lines @@
 
   canvas->DrawBitmapInt(*tab_inactive.image_l, 0, 0);
   canvas->TileImageInt(*tab_inactive.image_c,
                        tab_inactive.l_width, 0,
                        width() - tab_inactive.l_width - tab_inactive.r_width,
                        height());
   canvas->DrawBitmapInt(*tab_inactive.image_r,
                         width() - tab_inactive.r_width, 0);
 }
 
-void TabRenderer::PaintActiveTabBackground(ChromeCanvas* canvas) {
+void TabRenderer::PaintActiveTabBackground(gfx::Canvas* canvas) {
   int offset = GetX(views::View::APPLY_MIRRORING_TRANSFORMATION) + 1;
   ThemeProvider* tp = GetThemeProvider();
   if (!tp)
     NOTREACHED() << "Unable to get theme provider";
 
   SkBitmap* tab_bg = GetThemeProvider()->GetBitmapNamed(IDR_THEME_TOOLBAR);
 
   // Draw left edge.
   SkBitmap tab_l = skia::ImageOperations::CreateTiledBitmap(
       *tab_bg, offset, 0, tab_active.l_width, height());
@@ skipping 15 matching lines @@
      offset + tab_active.l_width, 2,
      tab_active.l_width, 2,
      width() - tab_active.l_width - tab_active.r_width, height() - 2);
 
   canvas->DrawBitmapInt(*tab_active.image_l, 0, 0);
   canvas->TileImageInt(*tab_active.image_c, tab_active.l_width, 0,
       width() - tab_active.l_width - tab_active.r_width, height());
   canvas->DrawBitmapInt(*tab_active.image_r, width() - tab_active.r_width, 0);
 }
 
-void TabRenderer::PaintHoverTabBackground(ChromeCanvas* canvas,
+void TabRenderer::PaintHoverTabBackground(gfx::Canvas* canvas,
                                           double opacity) {
   bool is_otr = data_.off_the_record;
   SkBitmap left = skia::ImageOperations::CreateBlendedBitmap(
                   *tab_inactive.image_l, *tab_active.image_l, opacity);
   SkBitmap center = skia::ImageOperations::CreateBlendedBitmap(
                     *tab_inactive.image_c, *tab_active.image_c, opacity);
   SkBitmap right = skia::ImageOperations::CreateBlendedBitmap(
                    *tab_inactive.image_r, *tab_active.image_r, opacity);
 
   canvas->DrawBitmapInt(left, 0, 0);
   canvas->TileImageInt(center, tab_active.l_width, 0,
       width() - tab_active.l_width - tab_active.r_width, height());
   canvas->DrawBitmapInt(right, width() - tab_active.r_width, 0);
 }
 
-void TabRenderer::PaintLoadingAnimation(ChromeCanvas* canvas) {
+void TabRenderer::PaintLoadingAnimation(gfx::Canvas* canvas) {
   SkBitmap* frames = (animation_state_ == ANIMATION_WAITING) ?
                       waiting_animation_frames : loading_animation_frames;
   int image_size = frames->height();
   int image_offset = animation_frame_ * image_size;
   int dst_y = (height() - image_size) / 2;
 
   // Just like with the Tab's title and favicon, the position for the page
   // loading animation also needs to be mirrored if the View's UI layout is
   // right-to-left.
   int dst_x;
@@ skipping 79 matching lines @@
   tab_inactive.image_l = rb.GetBitmapNamed(IDR_TAB_INACTIVE_LEFT);
   tab_inactive.image_c = rb.GetBitmapNamed(IDR_TAB_INACTIVE_CENTER);
   tab_inactive.image_r = rb.GetBitmapNamed(IDR_TAB_INACTIVE_RIGHT);
 
   tab_inactive.l_width = tab_inactive.image_l->width();
   tab_inactive.r_width = tab_inactive.image_r->width();
 
   loading_animation_frames = rb.GetBitmapNamed(IDR_THROBBER);
   waiting_animation_frames = rb.GetBitmapNamed(IDR_THROBBER_WAITING);
 }