Add extra overloads for color analysis.

ui/gfx/color_analysis.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/color_analysis.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 364 matching lines @@
     return CalculateKMeanColorOfBuffer(&decoded_data[0],
                                        img_width,
                                        img_height,
                                        darkness_limit,
                                        brightness_limit,
                                        sampler);
   }
   return color;
 }
 
-SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap) {
+SkColor CalculateKMeanColorOfPNG(scoped_refptr<base::RefCountedMemory> png) {
+  GridSampler sampler;
+  return CalculateKMeanColorOfPNG(png, kMinDarkness, kMaxBrightness, &sampler);
+}
+
+SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap,
+                                    uint32_t darkness_limit,
+                                    uint32_t brightness_limit,
+                                    KMeanImageSampler* sampler) {
   // SkBitmap uses pre-multiplied alpha but the KMean clustering function
   // above uses non-pre-multiplied alpha. Transform the bitmap before we
   // analyze it because the function reads each pixel multiple times.
   int pixel_count = bitmap.width() * bitmap.height();
   scoped_ptr<uint32_t[]> image(new uint32_t[pixel_count]);
   UnPreMultiply(bitmap, image.get(), pixel_count);
 
+  return CalculateKMeanColorOfBuffer(reinterpret_cast<uint8_t*>(image.get()),
+                                     bitmap.width(),
+                                     bitmap.height(),
+                                     darkness_limit,
+                                     brightness_limit,
+                                     sampler);
+}
+
+SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap) {
   GridSampler sampler;
-  SkColor color = CalculateKMeanColorOfBuffer(
-      reinterpret_cast<uint8_t*>(image.get()),
-      bitmap.width(),
-      bitmap.height(),
-      kMinDarkness,
-      kMaxBrightness,
-      &sampler);
-  return color;
+  return CalculateKMeanColorOfBitmap(
+      bitmap, kMinDarkness, kMaxBrightness, &sampler);
 }
 
 gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap) {
   // First need basic stats to normalize each channel separately.
   SkAutoLockPixels bitmap_lock(bitmap);
   gfx::Matrix3F covariance = gfx::Matrix3F::Zeros();
   if (!bitmap.getPixels())
     return covariance;
 
   // Assume ARGB_8888 format.
@@ skipping 142 matching lines @@
   gfx::Matrix3F covariance = ComputeColorCovariance(source_bitmap);
   gfx::Matrix3F eigenvectors = gfx::Matrix3F::Zeros();
   gfx::Vector3dF eigenvals = covariance.SolveEigenproblem(&eigenvectors);
   gfx::Vector3dF principal = eigenvectors.get_column(0);
   if (eigenvals == gfx::Vector3dF() || principal == gfx::Vector3dF())
     return false;  // This may happen for some edge cases.
   return ApplyColorReduction(source_bitmap, principal, true, target_bitmap);
 }
 
 }  // color_utils