Type conversion fixes, components/ edition.

components/favicon_base/favicon_util.cc

 // Copyright 2014 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 "components/favicon_base/favicon_util.h"
 
 #include <cmath>
 
 #include "components/favicon_base/favicon_types.h"
 #include "components/favicon_base/select_favicon_frames.h"
@@ skipping 37 matching lines @@
       }
     }
     png_reps.push_back(gfx::ImagePNGRep(best_candidate, 1.0f));
     return png_reps;
   }
 
   // Build a map which will be used to determine the scale used to
   // create a bitmap with given pixel size.
   std::map<int, float> desired_pixel_sizes;
   for (size_t i = 0; i < favicon_scales.size(); ++i) {
-    int pixel_size = std::ceil(favicon_size * favicon_scales[i]);
+    int pixel_size =
+        static_cast<int>(std::ceil(favicon_size * favicon_scales[i]));
     desired_pixel_sizes[pixel_size] = favicon_scales[i];
   }
 
   for (size_t i = 0; i < png_data.size(); ++i) {
     if (!png_data[i].is_valid())
       continue;
 
     const gfx::Size& pixel_size = png_data[i].pixel_size;
     if (pixel_size.width() != pixel_size.height())
       continue;
 
     std::map<int, float>::iterator it =
         desired_pixel_sizes.find(pixel_size.width());
     if (it == desired_pixel_sizes.end())
       continue;
 
     png_reps.push_back(gfx::ImagePNGRep(png_data[i].bitmap_data, it->second));
   }
 
   return png_reps;
 }
 
-// Returns a resampled bitmap of
-// |desired_size_in_pixel| x |desired_size_in_pixel| by resampling the best

[Peter Kasting, 2014/10/16 22:36:53]

Changing these names was mostly to reduce the line-wrapping at the end of the
function that MakeFromIRect() caused, but removing needless verbosity seemed
fine too.

-// bitmap out of |input_bitmaps|. ResizeBitmapByDownsamplingIfPossible() is
-// similar to SelectFaviconFrames() but it operates on bitmaps which have
-// already been resampled via SelectFaviconFrames().
+// Returns a resampled bitmap of |desired_size| x |desired_size| by resampling
+// the best bitmap out of |input_bitmaps|.
+// ResizeBitmapByDownsamplingIfPossible() is similar to SelectFaviconFrames()
+// but it operates on bitmaps which have already been resampled via
+// SelectFaviconFrames().
 SkBitmap ResizeBitmapByDownsamplingIfPossible(
     const std::vector<SkBitmap>& input_bitmaps,
-    int desired_size_in_pixel) {
+    int desired_size) {
   DCHECK(!input_bitmaps.empty());
-  DCHECK_NE(desired_size_in_pixel, 0);
+  DCHECK_NE(0, desired_size);
 
   SkBitmap best_bitmap;
   for (size_t i = 0; i < input_bitmaps.size(); ++i) {
     const SkBitmap& input_bitmap = input_bitmaps[i];
-    if (input_bitmap.width() == desired_size_in_pixel &&
-        input_bitmap.height() == desired_size_in_pixel) {
+    if (input_bitmap.width() == desired_size &&
+        input_bitmap.height() == desired_size) {
       return input_bitmap;
     } else if (best_bitmap.isNull()) {
       best_bitmap = input_bitmap;
     } else if (input_bitmap.width() >= best_bitmap.width() &&
                input_bitmap.height() >= best_bitmap.height()) {
-      if (best_bitmap.width() < desired_size_in_pixel ||
-          best_bitmap.height() < desired_size_in_pixel) {
+      if (best_bitmap.width() < desired_size ||
+          best_bitmap.height() < desired_size) {
         best_bitmap = input_bitmap;
       }
     } else {
-      if (input_bitmap.width() >= desired_size_in_pixel &&
-          input_bitmap.height() >= desired_size_in_pixel) {
+      if (input_bitmap.width() >= desired_size &&
+          input_bitmap.height() >= desired_size) {
         best_bitmap = input_bitmap;
       }
     }
   }
 
-  if (desired_size_in_pixel % best_bitmap.width() == 0 &&
-      desired_size_in_pixel % best_bitmap.height() == 0) {
+  if (desired_size % best_bitmap.width() == 0 &&
+      desired_size % best_bitmap.height() == 0) {
     // Use nearest neighbour resampling if upsampling by an integer. This
     // makes the result look similar to the result of SelectFaviconFrames().
     SkBitmap bitmap;
-    bitmap.allocN32Pixels(desired_size_in_pixel, desired_size_in_pixel);
+    bitmap.allocN32Pixels(desired_size, desired_size);
     if (!best_bitmap.isOpaque())
       bitmap.eraseARGB(0, 0, 0, 0);
 
     SkCanvas canvas(bitmap);
-    SkRect dest(SkRect::MakeWH(desired_size_in_pixel, desired_size_in_pixel));
-    canvas.drawBitmapRect(best_bitmap, NULL, dest);
+    canvas.drawBitmapRect(
+        best_bitmap, NULL,
+        SkRect::MakeFromIRect(SkIRect::MakeWH(desired_size, desired_size)));
     return bitmap;
   }
   return skia::ImageOperations::Resize(best_bitmap,
                                        skia::ImageOperations::RESIZE_LANCZOS3,
-                                       desired_size_in_pixel,
-                                       desired_size_in_pixel);
+                                       desired_size,
+                                       desired_size);
 }
 
 }  // namespace
 
 std::vector<float> GetFaviconScales() {
   const float kScale1x = 1.0f;
   std::vector<ui::ScaleFactor> resource_scale_factors =
       ui::GetSupportedScaleFactors();
 
   // TODO(ios): 1.0f should not be necessary on iOS retina devices. However
@@ skipping 65 matching lines @@
       bitmaps.push_back(bitmap);
     }
   }
 
   if (bitmaps.empty())
     return gfx::Image();
 
   gfx::ImageSkia resized_image_skia;
   for (size_t i = 0; i < favicon_scales_to_generate.size(); ++i) {
     float scale = favicon_scales_to_generate[i];
-    int desired_size_in_pixel = std::ceil(favicon_size * scale);
+    int desired_size_in_pixel =
+        static_cast<int>(std::ceil(favicon_size * scale));
     SkBitmap bitmap =
         ResizeBitmapByDownsamplingIfPossible(bitmaps, desired_size_in_pixel);
     resized_image_skia.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
   }
 
   if (png_reps.empty())
     return gfx::Image(resized_image_skia);
 
   std::vector<gfx::ImageSkiaRep> resized_image_skia_reps =
       resized_image_skia.image_reps();
   for (size_t i = 0; i < resized_image_skia_reps.size(); ++i) {
     scoped_refptr<base::RefCountedBytes> png_bytes(new base::RefCountedBytes());
     if (gfx::PNGCodec::EncodeBGRASkBitmap(
             resized_image_skia_reps[i].sk_bitmap(),
             false,
             &png_bytes->data())) {
       png_reps.push_back(
           gfx::ImagePNGRep(png_bytes, resized_image_skia_reps[i].scale()));
     }
   }
 
   return gfx::Image(png_reps);
 }
 
 }  // namespace favicon_base