Add extra overloads for color analysis.

ui/gfx/color_analysis.h

 // 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.
 
 #ifndef UI_GFX_COLOR_ANALYSIS_H_
 #define UI_GFX_COLOR_ANALYSIS_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
@@ skipping 34 matching lines @@
   private:
    // The number of times GetSample has been called.
    int calls_;
 };
 
 // Returns the color in an ARGB |image| that is closest in RGB-space to the
 // provided |color|. Exported for testing.
 GFX_EXPORT SkColor FindClosestColor(const uint8_t* image, int width, int height,
                                     SkColor color);
 
-// Returns an SkColor that represents the calculated dominant color in the png.
-// This uses a KMean clustering algorithm to find clusters of pixel colors in
-// RGB space.
-// |png| represents the data of a png encoded image.
+// Returns an SkColor that represents the calculated dominant color in the
+// image. This uses a KMean clustering algorithm to find clusters of pixel
+// colors in RGB space.
+// |png|/|bitmap| represents the data of a png/bitmap encoded image.
 // |darkness_limit| represents the minimum sum of the RGB components that is
 // acceptable as a color choice. This can be from 0 to 765.
 // |brightness_limit| represents the maximum sum of the RGB components that is
 // acceptable as a color choice. This can be from 0 to 765.
 //
 // RGB KMean Algorithm (N clusters, M iterations):
 // 1.Pick N starting colors by randomly sampling the pixels. If you see a
 //   color you already saw keep sampling. After a certain number of tries
 //   just remove the cluster and continue with N = N-1 clusters (for an image
 //   with just one color this should devolve to N=1). These colors are the
@@ skipping 18 matching lines @@
 //   If no color fulfills that requirement return the color with the largest
 //   weight regardless of whether or not it fulfills the equation above.
 //
 // Note: Switching to HSV space did not improve the results of this algorithm
 // for typical favicon images.
 GFX_EXPORT SkColor CalculateKMeanColorOfPNG(
     scoped_refptr<base::RefCountedMemory> png,
     uint32_t darkness_limit,
     uint32_t brightness_limit,
     KMeanImageSampler* sampler);
+// Computes a dominant color using the above algorithm and reasonable defaults
+// for |darkness_limit|, |brightness_limit| and |sampler|.
+GFX_EXPORT SkColor CalculateKMeanColorOfPNG(
+    scoped_refptr<base::RefCountedMemory> png);
 
-// Computes a dominant color for an SkBitmap using the above algorithm and
-// reasonable defaults for |darkness_limit|, |brightness_limit| and |sampler|.
+// Returns an SkColor that represents the calculated dominant color in the
+// image. See CalculateKMeanColorOfPNG() for details.
+GFX_EXPORT SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap,
+                                               uint32_t darkness_limit,
+                                               uint32_t brightness_limit,
+                                               KMeanImageSampler* sampler);
+// Computes a dominant color using the above algorithm and reasonable defaults
+// for |darkness_limit|, |brightness_limit| and |sampler|.
 GFX_EXPORT SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap);
 
 // Compute color covariance matrix for the input bitmap.
 GFX_EXPORT gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap);
 
 // Apply a color reduction transform defined by |color_transform| vector to
 // |source_bitmap|. The result is put into |target_bitmap|, which is expected
 // to be initialized to the required size and type (SkBitmap::kA8_Config).
 // If |fit_to_range|, result is transfored linearly to fit 0-0xFF range.
 // Otherwise, data is clipped.
 // Returns true if the target has been computed.
 GFX_EXPORT bool ApplyColorReduction(const SkBitmap& source_bitmap,
                                    const gfx::Vector3dF& color_transform,
                                    bool fit_to_range,
                                    SkBitmap* target_bitmap);
 
 // Compute a monochrome image representing the principal color component of
 // the |source_bitmap|. The result is stored in |target_bitmap|, which must be
 // initialized to the required size and type (SkBitmap::kA8_Config).
 // Returns true if the conversion succeeded. Note that there might be legitimate
 // reasons for the process to fail even if all input was correct. This is a
 // condition the caller must be able to handle.
 GFX_EXPORT bool ComputePrincipalComponentImage(const SkBitmap& source_bitmap,
                                               SkBitmap* target_bitmap);
 
 }  // namespace color_utils
 
 #endif  // UI_GFX_COLOR_ANALYSIS_H_