ChromeCanvas->gfx::Canvas

chrome/browser/gtk/tabs/tab_renderer_gtk.cc

 // Copyright (c) 2009 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/gtk/tabs/tab_renderer_gtk.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
@@ skipping 266 matching lines @@
 }
 
 void TabRendererGtk::AnimationEnded(const Animation* animation) {
   gtk_widget_queue_draw(tab_.get());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabRendererGtk, private:
 
 void TabRendererGtk::Paint(GdkEventExpose* event) {
-  ChromeCanvasPaint canvas(event, false);
+  gfx::CanvasPaint canvas(event, false);
   if (canvas.isEmpty())
     return;
 
   // 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();
@@ skipping 101 matching lines @@
   } else {
     title_width = std::max(local_bounds.width() - title_left, 0);
   }
   if (data_.show_download_icon)
     title_width = std::max(title_width - download_icon_width_, 0);
   title_bounds_.SetRect(title_left, title_top, title_width, title_font_height_);
 
   // TODO(jhawkins): Handle RTL layout.
 }
 
-void TabRendererGtk::PaintTabBackground(ChromeCanvasPaint* canvas) {
+void TabRendererGtk::PaintTabBackground(gfx::CanvasPaint* 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();
 
     PaintInactiveTabBackground(canvas);
     if (animation->GetCurrentValue() > 0) {
       SkRect bounds;
       // TODO(jhawkins): This will only work for the first tab, because
       // saveLayerAlpha only uses bounds as the size and not the location.  In
       // our situation, canvas spans the entire tabstrip, so saving the layer
       // at (0,0)x(w,h) will always save the first tab.
       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 TabRendererGtk::PaintInactiveTabBackground(ChromeCanvasPaint* canvas) {
+void TabRendererGtk::PaintInactiveTabBackground(gfx::CanvasPaint* 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 = 1;
   int offset_y = 20;
 
   int tab_id = is_otr ?
       IDR_THEME_TAB_BACKGROUND_INCOGNITO : IDR_THEME_TAB_BACKGROUND;
 
@@ skipping 30 matching lines @@
       width() - tab_active_.l_width - tab_active_.r_width, height() - 3);
 
   canvas->DrawBitmapInt(*tab_inactive_.image_l, bounds_.x(), bounds_.y());
   canvas->TileImageInt(*tab_inactive_.image_c, tab_inactive_.l_width, 0,
       bounds_.x() + width() - tab_inactive_.l_width - tab_inactive_.r_width,
       bounds_.y() + height());
   canvas->DrawBitmapInt(*tab_inactive_.image_r,
       bounds_.x() + width() - tab_inactive_.r_width, bounds_.y());
 }
 
-void TabRendererGtk::PaintActiveTabBackground(ChromeCanvasPaint* canvas) {
+void TabRendererGtk::PaintActiveTabBackground(gfx::CanvasPaint* canvas) {
   int offset = 1;
 
   SkBitmap* tab_bg = theme_provider_->GetBitmapNamed(IDR_THEME_TOOLBAR);
 
   // Draw left edge.
   SkBitmap tab_l = skia::ImageOperations::CreateTiledBitmap(
       *tab_bg, offset, 0, tab_active_.l_width, height());
   SkBitmap theme_l = skia::ImageOperations::CreateMaskedBitmap(
       tab_l, *tab_alpha.image_l);
   canvas->DrawBitmapInt(theme_l, bounds_.x(), bounds_.y());
@@ skipping 15 matching lines @@
       width() - tab_active_.l_width - tab_active_.r_width, height() - 2);
 
   canvas->DrawBitmapInt(*tab_active_.image_l, bounds_.x(), bounds_.y());
   canvas->TileImageInt(*tab_active_.image_c,
       bounds_.x() + tab_active_.l_width, bounds_.y(),
       width() - tab_active_.l_width - tab_active_.r_width, height());
   canvas->DrawBitmapInt(*tab_active_.image_r,
       bounds_.x() + width() - tab_active_.r_width, bounds_.y());
 }
 
-void TabRendererGtk::PaintLoadingAnimation(ChromeCanvasPaint* canvas) {
+void TabRendererGtk::PaintLoadingAnimation(gfx::CanvasPaint* canvas) {
   const SkBitmap* frames =
       (loading_animation_.animation_state() == ANIMATION_WAITING) ?
       loading_animation_.waiting_animation_frames() :
       loading_animation_.loading_animation_frames();
   const int image_size = frames->height();
   const int image_offset = loading_animation_.animation_frame() * image_size;
   const 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 UI layout is RTL.
@@ skipping 53 matching lines @@
   LoadTabImages();
 
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   title_font_ = new gfx::Font(rb.GetFont(ResourceBundle::BaseFont));
   title_font_height_ = title_font_->height();
 
   InitializeLoadingAnimationData(&rb, &loading_animation_data);
 
   initialized_ = true;
 }