Converts remainder of ui and chrome/browser/ui/views/frame to use ImageSkia

ui/base/native_theme/native_theme_base.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 "ui/base/native_theme/native_theme_base.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "grit/ui_resources_standard.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
+#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace {
 
 // These are the default dimensions of radio buttons and checkboxes.
 const int kCheckboxAndRadioWidth = 13;
 const int kCheckboxAndRadioHeight = 13;
 
 // These sizes match the sizes in Chromium Win.
@@ skipping 412 matching lines @@
                    paint);
     }
   }
 }
 
 void NativeThemeBase::PaintCheckbox(SkCanvas* canvas,
                                     State state,
                                     const gfx::Rect& rect,
                                     const ButtonExtraParams& button) const {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  SkBitmap* image = NULL;
+  gfx::ImageSkia* image = NULL;
   if (button.indeterminate) {
     image = state == kDisabled ?
-        rb.GetBitmapNamed(IDR_CHECKBOX_DISABLED_INDETERMINATE) :
-        rb.GetBitmapNamed(IDR_CHECKBOX_INDETERMINATE);
+        rb.GetImageSkiaNamed(IDR_CHECKBOX_DISABLED_INDETERMINATE) :
+        rb.GetImageSkiaNamed(IDR_CHECKBOX_INDETERMINATE);
   } else if (button.checked) {
     image = state == kDisabled ?
-        rb.GetBitmapNamed(IDR_CHECKBOX_DISABLED_ON) :
-        rb.GetBitmapNamed(IDR_CHECKBOX_ON);
+        rb.GetImageSkiaNamed(IDR_CHECKBOX_DISABLED_ON) :
+        rb.GetImageSkiaNamed(IDR_CHECKBOX_ON);
   } else {
     image = state == kDisabled ?
-        rb.GetBitmapNamed(IDR_CHECKBOX_DISABLED_OFF) :
-        rb.GetBitmapNamed(IDR_CHECKBOX_OFF);
+        rb.GetImageSkiaNamed(IDR_CHECKBOX_DISABLED_OFF) :
+        rb.GetImageSkiaNamed(IDR_CHECKBOX_OFF);
   }
 
   gfx::Rect bounds = rect.Center(gfx::Size(image->width(), image->height()));
   DrawBitmapInt(canvas, *image, 0, 0, image->width(), image->height(),
       bounds.x(), bounds.y(), bounds.width(), bounds.height());
 }
 
 void NativeThemeBase::PaintRadio(SkCanvas* canvas,
                                   State state,
                                   const gfx::Rect& rect,
                                   const ButtonExtraParams& button) const {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  SkBitmap* image = NULL;
+  gfx::ImageSkia* image = NULL;
   if (state == kDisabled) {
     image = button.checked ?
-        rb.GetBitmapNamed(IDR_RADIO_DISABLED_ON) :
-        rb.GetBitmapNamed(IDR_RADIO_DISABLED_OFF);
+        rb.GetImageSkiaNamed(IDR_RADIO_DISABLED_ON) :
+        rb.GetImageSkiaNamed(IDR_RADIO_DISABLED_OFF);
   } else {
     image = button.checked ?
-        rb.GetBitmapNamed(IDR_RADIO_ON) :
-        rb.GetBitmapNamed(IDR_RADIO_OFF);
+        rb.GetImageSkiaNamed(IDR_RADIO_ON) :
+        rb.GetImageSkiaNamed(IDR_RADIO_OFF);
   }
 
   gfx::Rect bounds = rect.Center(gfx::Size(image->width(), image->height()));
   DrawBitmapInt(canvas, *image, 0, 0, image->width(), image->height(),
       bounds.x(), bounds.y(), bounds.width(), bounds.height());
 }
 
 void NativeThemeBase::PaintButton(SkCanvas* canvas,
                                    State state,
                                    const gfx::Rect& rect,
@@ skipping 261 matching lines @@
 
   half.set_y(rect.y() + rect.height() / 2);
   PaintArrowButton(canvas, half, kScrollbarDownArrow, south_state);
 }
 
 void NativeThemeBase::PaintProgressBar(SkCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const ProgressBarExtraParams& progress_bar) const {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  SkBitmap* bar_image = rb.GetBitmapNamed(IDR_PROGRESS_BAR);
-  SkBitmap* left_border_image = rb.GetBitmapNamed(IDR_PROGRESS_BORDER_LEFT);
-  SkBitmap* right_border_image = rb.GetBitmapNamed(IDR_PROGRESS_BORDER_RIGHT);
+  gfx::ImageSkia* bar_image = rb.GetImageSkiaNamed(IDR_PROGRESS_BAR);
+  gfx::ImageSkia* left_border_image = rb.GetImageSkiaNamed(
+      IDR_PROGRESS_BORDER_LEFT);
+  gfx::ImageSkia* right_border_image = rb.GetImageSkiaNamed(
+      IDR_PROGRESS_BORDER_RIGHT);
 
   float tile_scale = static_cast<float>(rect.height()) /
       bar_image->height();
 
   int new_tile_width = static_cast<int>(bar_image->width() * tile_scale);
   float tile_scale_x = static_cast<float>(new_tile_width) /
       bar_image->width();
 
   DrawTiledImage(canvas, *bar_image, 0, 0, tile_scale_x, tile_scale,
       rect.x(), rect.y(), rect.width(), rect.height());
 
   if (progress_bar.value_rect_width) {
-    SkBitmap* value_image = rb.GetBitmapNamed(IDR_PROGRESS_VALUE);
+    gfx::ImageSkia* value_image = rb.GetImageSkiaNamed(IDR_PROGRESS_VALUE);
 
     new_tile_width = static_cast<int>(value_image->width() * tile_scale);
     tile_scale_x = static_cast<float>(new_tile_width) /
         value_image->width();
 
     DrawTiledImage(canvas, *value_image, 0, 0, tile_scale_x, tile_scale,
         progress_bar.value_rect_x,
         progress_bar.value_rect_y,
         progress_bar.value_rect_width,
         progress_bar.value_rect_height);
   }
 
   int dest_left_border_width = static_cast<int>(left_border_image->width() *
       tile_scale);
-  SkRect dest_rect;
-  dest_rect.iset(rect.x(), rect.y(), rect.x() + dest_left_border_width,
-                 rect.bottom());
-  canvas->drawBitmapRect(*left_border_image, NULL, dest_rect);
+  DrawBitmapInt(canvas, *left_border_image, 0, 0, left_border_image->width(),
+      left_border_image->height(), rect.x(), rect.y(), dest_left_border_width,
+      rect.height());
 
   int dest_right_border_width = static_cast<int>(right_border_image->width() *
       tile_scale);
-  dest_rect.iset(rect.right() - dest_right_border_width, rect.y(), rect.right(),
-                 rect.bottom());
-  canvas->drawBitmapRect(*right_border_image, NULL, dest_rect);
+  int dest_x = rect.right() - dest_right_border_width;
+  DrawBitmapInt(canvas, *right_border_image, 0, 0, right_border_image->width(),
+                right_border_image->height(), dest_x, rect.y(),
+                dest_right_border_width, rect.height());
 }
 
 bool NativeThemeBase::IntersectsClipRectInt(SkCanvas* canvas,
                                             int x, int y, int w, int h) const {
   SkRect clip;
   return canvas->getClipBounds(&clip) &&
       clip.intersect(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x + w),
                      SkIntToScalar(y + h));
 }
 
 void NativeThemeBase::DrawBitmapInt(
-    SkCanvas* canvas, const SkBitmap& bitmap,
+    SkCanvas* canvas, const gfx::ImageSkia& image,
     int src_x, int src_y, int src_w, int src_h,
     int dest_x, int dest_y, int dest_w, int dest_h) const {
-  gfx::Canvas(canvas).DrawBitmapInt(bitmap, src_x, src_y, src_w, src_h,
+  gfx::Canvas(canvas).DrawBitmapInt(image, src_x, src_y, src_w, src_h,
       dest_x, dest_y, dest_w, dest_h, true);
 }
 
 void NativeThemeBase::DrawTiledImage(SkCanvas* canvas,
-    const SkBitmap& bitmap,
+    const gfx::ImageSkia& image,
     int src_x, int src_y, float tile_scale_x, float tile_scale_y,
     int dest_x, int dest_y, int w, int h) const {
-  gfx::Canvas(canvas).TileImageInt(bitmap, src_x, src_y, tile_scale_x,
+  gfx::Canvas(canvas).TileImageInt(image, src_x, src_y, tile_scale_x,
       tile_scale_y, dest_x, dest_y, w, h);
 }
 
 SkColor NativeThemeBase::SaturateAndBrighten(SkScalar* hsv,
                                              SkScalar saturate_amount,
                                              SkScalar brighten_amount) const {
   SkScalar color[3];
   color[0] = hsv[0];
   color[1] = Clamp(hsv[1] + saturate_amount, 0.0, 1.0);
   color[2] = Clamp(hsv[2] + brighten_amount, 0.0, 1.0);
@@ skipping 68 matching lines @@
   SkScalar min_diff = Clamp((hsv1[1] + hsv2[1]) * 1.2f, 0.28f, 0.5f);
   SkScalar diff = Clamp(fabs(hsv1[2] - hsv2[2]) / 2, min_diff, 0.5f);
 
   if (hsv1[2] + hsv2[2] > 1.0)
     diff = -diff;
 
   return SaturateAndBrighten(hsv2, -0.2f, diff);
 }
 
 }  // namespace ui