Make the favicons look visually the same after refreshing

ui/gfx/image/image.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.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 106 matching lines @@
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromUIImage(
     UIImage* uiimage);
 // Caller takes ownership of the returned UIImage.
 UIImage* CreateUIImageFromPNG(
     const std::vector<gfx::ImagePNGRep>& image_png_reps);
 gfx::Size UIImageSize(UIImage* image);
 #elif defined(OS_MACOSX)
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromNSImage(
     NSImage* nsimage);
 // Caller takes ownership of the returned NSImage.
-NSImage* NSImageFromPNG(const std::vector<gfx::ImagePNGRep>& image_png_reps);
+NSImage* NSImageFromPNG(const std::vector<gfx::ImagePNGRep>& image_png_reps,
+                        CGColorSpaceRef color_space);
 gfx::Size NSImageSize(NSImage* image);
 #endif // defined(OS_MACOSX)
 
 #if defined(OS_IOS)
 ImageSkia* ImageSkiaFromPNG(
     const std::vector<gfx::ImagePNGRep>& image_png_reps);
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
     const ImageSkia* skia);
 #else
 // Returns a 16x16 red image to visually show error in decoding PNG.
@@ skipping 327 matching lines @@
 };
 #endif  // defined(OS_MACOSX)
 
 // The Storage class acts similarly to the pixels in a SkBitmap: the Image
 // class holds a refptr instance of Storage, which in turn holds all the
 // ImageReps. This way, the Image can be cheaply copied.
 class ImageStorage : public base::RefCounted<ImageStorage> {
  public:
   ImageStorage(gfx::Image::RepresentationType default_type)
       : default_representation_type_(default_type),
+#if defined(OS_MACOSX)
+        default_representation_color_space_(
+            base::mac::GetGenericRGBColorSpace()),
+#endif  // OS_MACOSX
         representations_deleter_(&representations_) {
   }
 
   gfx::Image::RepresentationType default_representation_type() {
     return default_representation_type_;
   }
   gfx::Image::RepresentationMap& representations() { return representations_; }
 
+#if defined(OS_MACOSX)
+  void set_default_representation_color_space(CGColorSpaceRef color_space) {
+    default_representation_color_space_ = color_space;
+  }
+  CGColorSpaceRef default_representation_color_space() {
+    return default_representation_color_space_;
+  }
+#endif  // OS_MACOSX
+
  private:
   friend class base::RefCounted<ImageStorage>;
 
   ~ImageStorage() {}
 
   // The type of image that was passed to the constructor. This key will always
   // exist in the |representations_| map.
   gfx::Image::RepresentationType default_representation_type_;
 
+#if defined(OS_MACOSX)
+  // The default representation's colorspace. This is used for converting to
+  // NSImage. This field exists to compensate for PNGCodec not writing or
+  // reading colorspace ancillary chunks. (sRGB, iCCP).
+  // Not owned.
+  CGColorSpaceRef default_representation_color_space_;
+#endif  // OS_MACOSX
+
   // All the representations of an Image. Size will always be at least one, with
   // more for any converted representations.
   gfx::Image::RepresentationMap representations_;
 
   STLValueDeleter<Image::RepresentationMap> representations_deleter_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageStorage);
 };
 
 }  // namespace internal
@@ skipping 201 matching lines @@
     }
     CHECK(rep);
     AddRepresentation(rep);
   }
   return rep->AsImageRepCocoaTouch()->image();
 }
 #elif defined(OS_MACOSX)
 NSImage* Image::ToNSImage() const {
   internal::ImageRep* rep = GetRepresentation(kImageRepCocoa, false);
   if (!rep) {
+    CGColorSpaceRef default_representation_color_space =
+        storage_->default_representation_color_space();
+
     switch (DefaultRepresentationType()) {
       case kImageRepPNG: {
         internal::ImageRepPNG* png_rep =
             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
         rep = new internal::ImageRepCocoa(internal::NSImageFromPNG(
-            png_rep->image_reps()));
+            png_rep->image_reps(), default_representation_color_space));
         break;
       }
       case kImageRepSkia: {
         internal::ImageRepSkia* skia_rep =
             GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
-        NSImage* image = NSImageFromImageSkia(*skia_rep->image());
+        NSImage* image = NSImageFromImageSkiaWithColorSpace(*skia_rep->image(),
+            default_representation_color_space);
         base::mac::NSObjectRetain(image);
         rep = new internal::ImageRepCocoa(image);
         break;
       }
       default:
         NOTREACHED();
     }
     CHECK(rep);
     AddRepresentation(rep);
   }
@@ skipping 154 matching lines @@
 gfx::Size Image::Size() const {
   if (IsEmpty())
     return gfx::Size();
   return GetRepresentation(DefaultRepresentationType(), true)->Size();
 }
 
 void Image::SwapRepresentations(gfx::Image* other) {
   storage_.swap(other->storage_);
 }
 
+#if defined(OS_MACOSX)
+void Image::SetSourceColorSpace(CGColorSpaceRef color_space) {
+  if (storage_.get())
+    storage_->set_default_representation_color_space(color_space);
+}
+#endif  // OS_MACOSX
+
 Image::RepresentationType Image::DefaultRepresentationType() const {
   CHECK(storage_.get());
   RepresentationType default_type = storage_->default_representation_type();
   // The conversions above assume that the default representation type is never
   // kImageRepCairo.
   DCHECK_NE(default_type, kImageRepCairo);
   return default_type;
 }
 
 internal::ImageRep* Image::GetRepresentation(
     RepresentationType rep_type, bool must_exist) const {
   CHECK(storage_.get());
   RepresentationMap::iterator it = storage_->representations().find(rep_type);
   if (it == storage_->representations().end()) {
     CHECK(!must_exist);
     return NULL;
   }
   return it->second;
 }
 
 void Image::AddRepresentation(internal::ImageRep* rep) const {
   CHECK(storage_.get());
   storage_->representations().insert(std::make_pair(rep->type(), rep));
 }
 
 }  // namespace gfx