ui/gfx: remove redundant erase operations and remove unused function

ui/gfx/skbitmap_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/skbitmap_operations.h"
 
 #include <algorithm>
 #include <string.h>
 
 #include "base/logging.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/size.h"
 
 // static
 SkBitmap SkBitmapOperations::CreateInvertedBitmap(const SkBitmap& image) {
   DCHECK(image.colorType() == kN32_SkColorType);
 
   SkAutoLockPixels lock_image(image);
 
   SkBitmap inverted;
   inverted.allocN32Pixels(image.width(), image.height());

[danakj, 2014/07/16 15:18:25]

will it be filled with opaque values? you can save the alloc clearing everything
if so by passing that info along here.

[hyunki, 2014/07/16 15:28:48]

Yes. I think so. Please check below codes to fill all dst_row[x] 32 bits.

  for (int y = 0; y < image.height(); ++y) {
    uint32* image_row = image.getAddr32(0, y);
    uint32* dst_row = inverted.getAddr32(0, y);

    for (int x = 0; x < image.width(); ++x) {
      uint32 image_pixel = image_row[x];
      dst_row[x] = (image_pixel & 0xFF000000) |
                   (0x00FFFFFF - (image_pixel & 0x00FFFFFF));
    }
  }

[danakj, 2014/07/16 15:30:42]

It depends on the input image right?

[hyunki, 2014/07/16 15:35:16]

Yes. It depends on the input image. All alphas for dst_row will be computed and
filled.

dst_row[x] = (image_pixel & 0xFF000000) |
                   (0x00FFFFFF - (image_pixel & 0x00FFFFFF));

[danakj, 2014/07/16 15:38:11]

So, do you want to tell allocN32 if it will be opaque and avoid the implicit
erase inside there?

[hyunki, 2014/07/16 15:42:17]

No. I'm telling below operation fills whole alloced pixels because it covers
whole 32bit and double for-loops covers "image.width() * image.height()" area.

dst_row[x] = (image_pixel & 0xFF000000) |
                   (0x00FFFFFF - (image_pixel & 0x00FFFFFF));

[danakj, 2014/07/16 15:52:29]

So then how about passing true for opaque to allocN32Pixels?

[hyunki, 2014/07/16 16:03:03]

Sorry. For clarification,

(your question) will it be filled with opaque values? 
(my anwser) No, as I mentioned above, it depends on the input image.

Since allocN32Pixels will set |isOpaque| to false by default,
I think just current code changes would be fine.

-  inverted.eraseARGB(0, 0, 0, 0);
 
   for (int y = 0; y < image.height(); ++y) {
     uint32* image_row = image.getAddr32(0, y);
     uint32* dst_row = inverted.getAddr32(0, y);
 
     for (int x = 0; x < image.width(); ++x) {
       uint32 image_pixel = image_row[x];
       dst_row[x] = (image_pixel & 0xFF000000) |
                    (0x00FFFFFF - (image_pixel & 0x00FFFFFF));
     }
   }
 
   return inverted;
 }
 
 // static
-SkBitmap SkBitmapOperations::CreateSuperimposedBitmap(const SkBitmap& first,
-                                                      const SkBitmap& second) {
-  DCHECK(first.width() == second.width());
-  DCHECK(first.height() == second.height());
-  DCHECK(first.bytesPerPixel() == second.bytesPerPixel());
-  DCHECK(first.colorType() == kN32_SkColorType);
-
-  SkAutoLockPixels lock_first(first);
-  SkAutoLockPixels lock_second(second);
-
-  SkBitmap superimposed;
-  superimposed.allocN32Pixels(first.width(), first.height());
-  superimposed.eraseARGB(0, 0, 0, 0);
-
-  SkCanvas canvas(superimposed);
-
-  SkRect rect;
-  rect.fLeft = 0;
-  rect.fTop = 0;
-  rect.fRight = SkIntToScalar(first.width());
-  rect.fBottom = SkIntToScalar(first.height());
-
-  canvas.drawBitmapRect(first, NULL, rect);
-  canvas.drawBitmapRect(second, NULL, rect);
-
-  return superimposed;
-}
-
-// static
 SkBitmap SkBitmapOperations::CreateBlendedBitmap(const SkBitmap& first,
                                                  const SkBitmap& second,
                                                  double alpha) {
   DCHECK((alpha >= 0) && (alpha <= 1));
   DCHECK(first.width() == second.width());
   DCHECK(first.height() == second.height());
   DCHECK(first.bytesPerPixel() == second.bytesPerPixel());
   DCHECK(first.colorType() == kN32_SkColorType);
 
   // Optimize for case where we won't need to blend anything.
   static const double alpha_min = 1.0 / 255;
   static const double alpha_max = 254.0 / 255;
   if (alpha < alpha_min)
     return first;
   else if (alpha > alpha_max)
     return second;
 
   SkAutoLockPixels lock_first(first);
   SkAutoLockPixels lock_second(second);
 
   SkBitmap blended;
   blended.allocN32Pixels(first.width(), first.height());
-  blended.eraseARGB(0, 0, 0, 0);

[danakj, 2014/07/16 15:18:25]

ditto for the rest

[hyunki, 2014/07/16 15:28:48]

ditto.

 dst_row[x] = SkColorSetARGB(a, r, g, b);

 
   double first_alpha = 1 - alpha;
 
   for (int y = 0; y < first.height(); ++y) {
     uint32* first_row = first.getAddr32(0, y);
     uint32* second_row = second.getAddr32(0, y);
     uint32* dst_row = blended.getAddr32(0, y);
 
     for (int x = 0; x < first.width(); ++x) {
       uint32 first_pixel = first_row[x];
@@ skipping 19 matching lines @@
 SkBitmap SkBitmapOperations::CreateMaskedBitmap(const SkBitmap& rgb,
                                                 const SkBitmap& alpha) {
   DCHECK(rgb.width() == alpha.width());
   DCHECK(rgb.height() == alpha.height());
   DCHECK(rgb.bytesPerPixel() == alpha.bytesPerPixel());
   DCHECK(rgb.colorType() == kN32_SkColorType);
   DCHECK(alpha.colorType() == kN32_SkColorType);
 
   SkBitmap masked;
   masked.allocN32Pixels(rgb.width(), rgb.height());
-  masked.eraseARGB(0, 0, 0, 0);
 
   SkAutoLockPixels lock_rgb(rgb);
   SkAutoLockPixels lock_alpha(alpha);
   SkAutoLockPixels lock_masked(masked);
 
   for (int y = 0; y < masked.height(); ++y) {
     uint32* rgb_row = rgb.getAddr32(0, y);
     uint32* alpha_row = alpha.getAddr32(0, y);
     uint32* dst_row = masked.getAddr32(0, y);
 
@@ skipping 395 matching lines @@
     L_op = HSLShift::kOpLInc;
 
   HSLShift::LineProcessor line_proc =
       HSLShift::kLineProcessors[H_op][S_op][L_op];
 
   DCHECK(bitmap.empty() == false);
   DCHECK(bitmap.colorType() == kN32_SkColorType);
 
   SkBitmap shifted;
   shifted.allocN32Pixels(bitmap.width(), bitmap.height());
-  shifted.eraseARGB(0, 0, 0, 0);
 
   SkAutoLockPixels lock_bitmap(bitmap);
   SkAutoLockPixels lock_shifted(shifted);
 
   // Loop through the pixels of the original bitmap.
   for (int y = 0; y < bitmap.height(); ++y) {
     SkPMColor* pixels = bitmap.getAddr32(0, y);
     SkPMColor* tinted_pixels = shifted.getAddr32(0, y);
 
     (*line_proc)(hsl_shift, pixels, tinted_pixels, bitmap.width());
   }
 
   return shifted;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateTiledBitmap(const SkBitmap& source,
                                                int src_x, int src_y,
                                                int dst_w, int dst_h) {
   DCHECK(source.colorType() == kN32_SkColorType);
 
   SkBitmap cropped;
   cropped.allocN32Pixels(dst_w, dst_h);
-  cropped.eraseARGB(0, 0, 0, 0);
 
   SkAutoLockPixels lock_source(source);
   SkAutoLockPixels lock_cropped(cropped);
 
   // Loop through the pixels of the original bitmap.
   for (int y = 0; y < dst_h; ++y) {
     int y_pix = (src_y + y) % source.height();
     while (y_pix < 0)
       y_pix += source.height();
 
@@ skipping 229 matching lines @@
   canvas.translate(SkFloatToScalar(result.width() * 0.5f),
                    SkFloatToScalar(result.height() * 0.5f));
   canvas.rotate(angle);
   canvas.translate(-SkFloatToScalar(source.width() * 0.5f),
                    -SkFloatToScalar(source.height() * 0.5f));
   canvas.drawBitmap(source, 0, 0);
   canvas.flush();
 
   return result;
 }