Resize images for hi-dpi based on a custom PNG chunk added by GRIT r78, and roll GRIT r78

ui/gfx/codec/png_codec.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/codec/png_codec.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "ui/gfx/size.h"
@@ skipping 76 matching lines @@
 // This code is based on WebKit libpng interface (PNGImageDecoder), which is
 // in turn based on the Mozilla png decoder.
 
 namespace {
 
 // Gamma constants: We assume we're on Windows which uses a gamma of 2.2.
 const double kMaxGamma = 21474.83;  // Maximum gamma accepted by png library.
 const double kDefaultGamma = 2.2;
 const double kInverseGamma = 1.0 / kDefaultGamma;
 
+const png_byte kPngScaleChunk[5] = { 'c', 's', 'C', 'l', 0 };
+
 class PngDecoderState {
  public:
   // Output is a vector<unsigned char>.
   PngDecoderState(PNGCodec::ColorFormat ofmt, std::vector<unsigned char>* o)
       : output_format(ofmt),
         output_channels(0),
         bitmap(NULL),
         is_opaque(true),
         output(o),
         width(0),
         height(0),
+        scale_fallback(false),
         done(false) {
   }
 
   // Output is an SkBitmap.
   explicit PngDecoderState(SkBitmap* skbitmap)
       : output_format(PNGCodec::FORMAT_SkBitmap),
         output_channels(0),
         bitmap(skbitmap),
         is_opaque(true),
         output(NULL),
         width(0),
         height(0),
+        scale_fallback(false),
         done(false) {
   }
 
   PNGCodec::ColorFormat output_format;
   int output_channels;
 
   // An incoming SkBitmap to write to. If NULL, we write to output instead.
   SkBitmap* bitmap;
 
   // Used during the reading of an SkBitmap. Defaults to true until we see a
   // pixel with anything other than an alpha of 255.
   bool is_opaque;
 
   // The other way to decode output, where we write into an intermediary buffer
   // instead of directly to an SkBitmap.
   std::vector<unsigned char>* output;
 
   // Size of the image, set in the info callback.
   int width;
   int height;
 
+  // True if a csCl chunk is present, indicating that GRIT didn't find an image
+  // at the proper scale and fell back to 100%.
+  bool scale_fallback;
+
   // Set to true when we've found the end of the data.
   bool done;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PngDecoderState);
 };
 
 // User transform (passed to libpng) which converts a row decoded by libpng to
 // Skia format. Expects the row to have 4 channels, otherwise there won't be
 // enough room in |data|.
@@ skipping 172 matching lines @@
 
 void DecodeEndCallback(png_struct* png_ptr, png_info* info) {
   PngDecoderState* state = static_cast<PngDecoderState*>(
       png_get_progressive_ptr(png_ptr));
 
   // Mark the image as complete, this will tell the Decode function that we
   // have successfully found the end of the data.
   state->done = true;
 }
 
+int DecodeUserChunkCallback(png_struct* png_ptr, png_unknown_chunk* chunk) {
+  PngDecoderState* state = static_cast<PngDecoderState*>(
+      png_get_user_chunk_ptr(png_ptr));
+  DCHECK(memcmp(chunk->name, kPngScaleChunk, 5) == 0);  // guaranteed by libpng

[sail, 2012/10/09 22:01:37]

sentence fragment 

[benrg, 2012/10/10 02:18:13]

Done.

+  if (chunk->size == 0) {
+    state->scale_fallback = true;
+    return 1;  // processed
+  }
+  return 0;  // unrecognized
+}
+
 // Automatically destroys the given read structs on destruction to make
 // cleanup and error handling code cleaner.
 class PngReadStructDestroyer {
  public:
   PngReadStructDestroyer(png_struct** ps, png_info** pi) : ps_(ps), pi_(pi) {
   }
   ~PngReadStructDestroyer() {
     png_destroy_read_struct(ps_, pi_, NULL);
   }
  private:
@@ skipping 56 matching lines @@
 
 void LogLibPNGEncodeError(png_structp png_ptr, png_const_charp error_msg) {
   DLOG(ERROR) << "libpng encode error: " << error_msg;
   longjmp(png_jmpbuf(png_ptr), 1);
 }
 
 void LogLibPNGEncodeWarning(png_structp png_ptr, png_const_charp warning_msg) {
   DLOG(ERROR) << "libpng encode warning: " << warning_msg;
 }
 
-}  // namespace
-
-// static
-bool PNGCodec::Decode(const unsigned char* input, size_t input_size,
-                      ColorFormat format, std::vector<unsigned char>* output,
-                      int* w, int* h) {
+bool DecodeInternal(const unsigned char* input, size_t input_size,
+                    PngDecoderState* state) {
   png_struct* png_ptr = NULL;
   png_info* info_ptr = NULL;
   if (!BuildPNGStruct(input, input_size, &png_ptr, &info_ptr))
     return false;
 
   PngReadStructDestroyer destroyer(&png_ptr, &info_ptr);
   if (setjmp(png_jmpbuf(png_ptr))) {
     // The destroyer will ensure that the structures are cleaned up in this
     // case, even though we may get here as a jump from random parts of the
     // PNG library called below.
     return false;
   }
 
+  png_set_error_fn(png_ptr, NULL, LogLibPNGDecodeError, LogLibPNGDecodeWarning);
+  png_set_progressive_read_fn(png_ptr, state, DecodeInfoCallback,
+                              DecodeRowCallback, DecodeEndCallback);
+  png_set_keep_unknown_chunks(png_ptr, 3, const_cast<png_byte*>(kPngScaleChunk),
+                              1);  // keep only csCl
+  png_set_read_user_chunk_fn(png_ptr, state, DecodeUserChunkCallback);
+  png_process_data(png_ptr, info_ptr,
+                   const_cast<unsigned char*>(input), input_size);
+  return state->done;
+}
+
+}  // namespace
+
+
+// static
+bool PNGCodec::Decode(const unsigned char* input, size_t input_size,
+                      ColorFormat format, std::vector<unsigned char>* output,
+                      int* w, int* h) {
   PngDecoderState state(format, output);
-
-  png_set_error_fn(png_ptr, NULL, LogLibPNGDecodeError, LogLibPNGDecodeWarning);
-  png_set_progressive_read_fn(png_ptr, &state, &DecodeInfoCallback,
-                              &DecodeRowCallback, &DecodeEndCallback);
-  png_process_data(png_ptr,
-                   info_ptr,
-                   const_cast<unsigned char*>(input),
-                   input_size);
-
-  if (!state.done) {
-    // Fed it all the data but the library didn't think we got all the data, so
-    // this file must be truncated.
+  if (!DecodeInternal(input, input_size, &state)) {
     output->clear();
     return false;
   }
-
   *w = state.width;
   *h = state.height;
   return true;
 }
 
 // static
 bool PNGCodec::Decode(const unsigned char* input, size_t input_size,
+                      SkBitmap* bitmap, bool* scale_fallback) {
+  DCHECK(bitmap);
+  PngDecoderState state(bitmap);
+  if (!DecodeInternal(input, input_size, &state))
+    return false;
+  bitmap->setIsOpaque(state.is_opaque);
+  if (scale_fallback)
+    *scale_fallback = state.scale_fallback;
+  return true;
+}
+
+// static
+bool PNGCodec::Decode(const unsigned char* input, size_t input_size,
                       SkBitmap* bitmap) {
-  DCHECK(bitmap);
-  png_struct* png_ptr = NULL;
-  png_info* info_ptr = NULL;
-  if (!BuildPNGStruct(input, input_size, &png_ptr, &info_ptr))
-    return false;
-
-  PngReadStructDestroyer destroyer(&png_ptr, &info_ptr);
-  if (setjmp(png_jmpbuf(png_ptr))) {
-    // The destroyer will ensure that the structures are cleaned up in this
-    // case, even though we may get here as a jump from random parts of the
-    // PNG library called below.
-    return false;
-  }
-
-  PngDecoderState state(bitmap);
-
-  png_set_progressive_read_fn(png_ptr, &state, &DecodeInfoCallback,
-                              &DecodeRowCallback, &DecodeEndCallback);
-  png_process_data(png_ptr,
-                   info_ptr,
-                   const_cast<unsigned char*>(input),
-                   input_size);
-
-  if (!state.done) {
-    return false;
-  }
-
-  // Set the bitmap's opaqueness based on what we saw.
-  bitmap->setIsOpaque(state.is_opaque);
-
-  return true;
+  return Decode(input, input_size, bitmap, NULL);
 }
 
 // static
 SkBitmap* PNGCodec::CreateSkBitmapFromBGRAFormat(
     std::vector<unsigned char>& bgra, int width, int height) {
   SkBitmap* bitmap = new SkBitmap();
   bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height);
   bitmap->allocPixels();
 
   bool opaque = false;
@@ skipping 289 matching lines @@
 }
 
 PNGCodec::Comment::Comment(const std::string& k, const std::string& t)
     : key(k), text(t) {
 }
 
 PNGCodec::Comment::~Comment() {
 }
 
 }  // namespace gfx