Use RAII for write libpng structs.

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 343 matching lines @@
   PngReadStructDestroyer(png_struct** ps, png_info** pi) : ps_(ps), pi_(pi) {
   }
   ~PngReadStructDestroyer() {
     png_destroy_read_struct(ps_, pi_, NULL);
   }
  private:
   png_struct** ps_;
   png_info** pi_;
 };
 
+// Automatically destroys the given write structs on destruction to make
+// cleanup and error handling code cleaner.
+class PngWriteStructDestroyer {
+ public:
+  explicit PngWriteStructDestroyer(png_struct** ps) : ps_(ps), pi_(0) {
+  }
+  ~PngWriteStructDestroyer() {
+    png_destroy_write_struct(ps_, pi_);
+  }
+  void SetInfoStruct(png_info** pi) {
+    pi_ = pi;
+  }
+ private:
+  png_struct** ps_;
+  png_info** pi_;
+};

[sky, 2012/04/02 15:35:01]

DISALLOW_COPY_AND_ASSIGN

+
 bool BuildPNGStruct(const unsigned char* input, size_t input_size,
                     png_struct** png_ptr, png_info** info_ptr) {
   if (input_size < 8)
     return false;  // Input data too small to be a png
 
   // Have libpng check the signature, it likes the first 8 bytes.
   if (png_sig_cmp(const_cast<unsigned char*>(input), 0, 8) != 0)
     return false;
 
   *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
@@ skipping 365 matching lines @@
       return false;
   }
 
   // Row stride should be at least as long as the length of the data.
   DCHECK(input_color_components * size.width() <= row_byte_width);
 
   png_struct* png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
                                                 NULL, NULL, NULL);
   if (!png_ptr)
     return false;
+  PngWriteStructDestroyer destroyer(&png_ptr);
   png_info* info_ptr = png_create_info_struct(png_ptr);
-  if (!info_ptr) {
-    png_destroy_write_struct(&png_ptr, NULL);
+  if (!info_ptr)
     return false;
-  }
+  destroyer.SetInfoStruct(&info_ptr);
 
   PngEncoderState state(output);
   bool success = DoLibpngWrite(png_ptr, info_ptr, &state,
                                size.width(), size.height(), row_byte_width,
                                input, compression_level, png_output_color_type,
                                output_color_components, converter, comments);
-  png_destroy_write_struct(&png_ptr, &info_ptr);
 
   return success;
 }
 
 // static
 bool PNGCodec::EncodeBGRASkBitmap(const SkBitmap& input,
                                   bool discard_transparency,
                                   std::vector<unsigned char>* output) {
   static const int bbp = 4;
 
   SkAutoLockPixels lock_input(input);
   DCHECK(input.empty() || input.bytesPerPixel() == bbp);
 
   return Encode(reinterpret_cast<unsigned char*>(input.getAddr32(0, 0)),
                 FORMAT_SkBitmap, Size(input.width(), input.height()),
                 input.width() * bbp, discard_transparency,
                 std::vector<Comment>(), output);
 }
 
 PNGCodec::Comment::Comment(const std::string& k, const std::string& t)
     : key(k), text(t) {
 }
 
 PNGCodec::Comment::~Comment() {
 }
 
 }  // namespace gfx