Add additional error handling and null checking to ImageSkiaOperations

ui/gfx/image/image_skia_operations.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/gfx/image/image_skia_operations.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/layout.h"
@@ skipping 18 matching lines @@
   static bool scale_images = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableScalingInImageSkiaOperations);
   return scale_images;
 }
 
 // Creates 2x scaled image of the give |source|.
 ImageSkiaRep Create2XImageSkiaRep(const ImageSkiaRep& source) {
   gfx::Size size(source.GetWidth() * 2.0f, source.GetHeight() * 2.0f);
 
   SkBitmap resized_bitmap;
-  resized_bitmap.setConfig(SkBitmap::kARGB_8888_Config, size.width(), 
+  resized_bitmap.setConfig(SkBitmap::kARGB_8888_Config, size.width(),
                            size.height());
   if (!resized_bitmap.allocPixels())
     SK_CRASH();
   SkCanvas canvas(resized_bitmap);
   SkRect resized_bounds = RectToSkRect(gfx::Rect(size));
   canvas.drawBitmapRect(source.sk_bitmap(), NULL, resized_bounds);
   return ImageSkiaRep(resized_bitmap, ui::SCALE_FACTOR_200P);
 }
 
 // A utility function to synchronize the scale factor of the two images.
-// When the command line option "--disable-scaling-in-image-skia-operation"
-// is provided, this function will fail if the scale factors of the two images
-// are different. This assumes that the platform only supports
+// When the command line option "--enable-scaling-in-image-skia-operation"
+// is not provided, this function will fail if the scale factors of the two
+// image reps are different. This assumes that the platform only supports
 // 1x and 2x scale factors.
 // TODO(oshima): Remove and replace this with plain CHECK once
 // 2x images for all resources are provided.
 void MatchScale(ImageSkiaRep* first, ImageSkiaRep* second) {
   if (first->scale_factor() != second->scale_factor()) {
     CHECK(ScalingEnabled());
     ImageSkiaRep* target = NULL;
     if (first->scale_factor() == ui::SCALE_FACTOR_100P) {
       target = first;
     } else {
       target = second;
     }
     *target = Create2XImageSkiaRep(*target);
   }
 }
 
+// Returns an image rep for the ImageSkiaSource to return to visually indicate
+// an error.
+ImageSkiaRep GetErrorImageRep(ui::ScaleFactor scale_factor) {
+  SkBitmap bitmap;
+  bitmap.setConfig(SkBitmap::kARGB_8888_Config, 32, 32);
+  bitmap.allocPixels();
+  bitmap.eraseColor(SK_ColorRED);
+  return gfx::ImageSkiaRep(bitmap, scale_factor);
+}
+
 class BlendingImageSource : public gfx::ImageSkiaSource {
  public:
   BlendingImageSource(const ImageSkia& first,
                       const ImageSkia& second,
                       double alpha)
       : first_(first),
         second_(second),
         alpha_(alpha) {
   }
 
   virtual ~BlendingImageSource() {
   }
 
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep first_rep = first_.GetRepresentation(scale_factor);
     ImageSkiaRep second_rep = second_.GetRepresentation(scale_factor);
     MatchScale(&first_rep, &second_rep);
+
+    // It is possible for the sizes to be different because the sizes of the
+    // image reps do not have to be related to the sizes of the containing
+    // ImageSkias.
+    if (first_rep.pixel_size() != second_rep.pixel_size()) {
+      LOG(ERROR) << "ImageSkiaRep size mismatch in BlendingImageSource";
+      return GetErrorImageRep(scale_factor);
+    }
+
     SkBitmap blended = SkBitmapOperations::CreateBlendedBitmap(
         first_rep.sk_bitmap(), second_rep.sk_bitmap(), alpha_);
     return ImageSkiaRep(blended, first_rep.scale_factor());
   }
 
  private:
   const ImageSkia first_;
   const ImageSkia second_;
   double alpha_;
 
@@ skipping 63 matching lines @@
         alpha_(alpha) {
   }
 
   virtual ~MaskedImageSource() {
   }
 
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep rgb_rep = rgb_.GetRepresentation(scale_factor);
     ImageSkiaRep alpha_rep = alpha_.GetRepresentation(scale_factor);
-    CHECK_EQ(rgb_rep.pixel_width(), alpha_rep.pixel_width());
-    CHECK_EQ(rgb_rep.pixel_height(), alpha_rep.pixel_height());
+    if (rgb_rep.pixel_size() != alpha_rep.pixel_size()) {
+      LOG(ERROR) << "ImageSkiaRep size mismatch in MaskedImageSource";
+      return GetErrorImageRep(scale_factor);
+    }
+
     return ImageSkiaRep(SkBitmapOperations::CreateMaskedBitmap(
         rgb_rep.sk_bitmap(), alpha_rep.sk_bitmap()),
                         rgb_rep.scale_factor());
   }
 
  private:
   const ImageSkia rgb_;
   const ImageSkia alpha_;
 
   DISALLOW_COPY_AND_ASSIGN(MaskedImageSource);
@@ skipping 73 matching lines @@
         mask_(mask) {
   }
 
   virtual ~ButtonImageSource() {
   }
 
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep image_rep = image_.GetRepresentation(scale_factor);
     ImageSkiaRep mask_rep = mask_.GetRepresentation(scale_factor);
-    MatchScale(&image_rep, &mask_rep);
+    if (image_rep.pixel_size() != mask_rep.pixel_size()) {
+      LOG(ERROR) << "ImageSkiaRep size mismatch in ButtonImageSource";
+      return GetErrorImageRep(scale_factor);
+    }
+
     return ImageSkiaRep(
         SkBitmapOperations::CreateButtonBackground(color_,
             image_rep.sk_bitmap(), mask_rep.sk_bitmap()),
         image_rep.scale_factor());
   }
 
  private:
   const SkColor color_;
   const ImageSkia image_;
   const ImageSkia mask_;
@@ skipping 132 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(RotatedSource);
 };
 
 
 }  // namespace
 
 // static
 ImageSkia ImageSkiaOperations::CreateBlendedImage(const ImageSkia& first,
                                                   const ImageSkia& second,
                                                   double alpha) {
+  if (first.isNull() || second.isNull() || first.size() != second.size())
+    return ImageSkia();
+
   return ImageSkia(new BlendingImageSource(first, second, alpha), first.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateSuperimposedImage(
     const ImageSkia& first,
     const ImageSkia& second) {
+  if (first.isNull() || second.isNull())
+    return ImageSkia();
+
   return ImageSkia(new SuperimposedImageSource(first, second), first.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateTransparentImage(const ImageSkia& image,
                                                       double alpha) {
+  if (image.isNull())
+    return ImageSkia();
+
   return ImageSkia(new TransparentImageSource(image, alpha), image.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateMaskedImage(const ImageSkia& rgb,
                                                  const ImageSkia& alpha) {
+  if (rgb.isNull() || alpha.isNull() || rgb.size() != alpha.size())
+    return ImageSkia();
+
   return ImageSkia(new MaskedImageSource(rgb, alpha), rgb.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateTiledImage(const ImageSkia& source,
                                                 int src_x, int src_y,
                                                 int dst_w, int dst_h) {
+  if (source.isNull())
+    return ImageSkia();
+
   return ImageSkia(new TiledImageSource(source, src_x, src_y, dst_w, dst_h),
                    gfx::Size(dst_w, dst_h));
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateHSLShiftedImage(
     const ImageSkia& image,
     const color_utils::HSL& hsl_shift) {
+  if (image.isNull())
+    return ImageSkia();
+
   return ImageSkia(new HSLImageSource(image, hsl_shift), image.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateButtonBackground(SkColor color,
                                                       const ImageSkia& image,
                                                       const ImageSkia& mask) {
+  if (image.isNull() || mask.isNull() || image.size() != mask.size())
+    return ImageSkia();
+
   return ImageSkia(new ButtonImageSource(color, image, mask), mask.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::ExtractSubset(const ImageSkia& image,
                                              const Rect& subset_bounds) {
   gfx::Rect clipped_bounds =
       gfx::IntersectRects(subset_bounds, gfx::Rect(image.size()));
   if (image.isNull() || clipped_bounds.IsEmpty()) {
     return ImageSkia();
   }
 
   return ImageSkia(new ExtractSubsetImageSource(image, clipped_bounds),
                    clipped_bounds.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateResizedImage(
     const ImageSkia& source,
     skia::ImageOperations::ResizeMethod method,
     const Size& target_dip_size) {
+  if (source.isNull())
+    return ImageSkia();
+
   return ImageSkia(new ResizeSource(source, method, target_dip_size),
                    target_dip_size);
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateImageWithDropShadow(
     const ImageSkia& source,
     const ShadowValues& shadows) {
+  if (source.isNull())
+    return ImageSkia();
+
   const gfx::Insets shadow_padding = -gfx::ShadowValue::GetMargin(shadows);
   gfx::Size shadow_image_size = source.size();
   shadow_image_size.Enlarge(shadow_padding.width(),
                             shadow_padding.height());
   return ImageSkia(new DropShadowSource(source, shadows), shadow_image_size);
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateRotatedImage(
       const ImageSkia& source,
       SkBitmapOperations::RotationAmount rotation) {
+  if (source.isNull())
+    return ImageSkia();
+
   return ImageSkia(new RotatedSource(source, rotation),
       SkBitmapOperations::ROTATION_180_CW == rotation ?
           source.size() :
           gfx::Size(source.height(), source.width()));
 
 }
 
 }  // namespace gfx