Move simple png encoding for image_diff into tools/

tools/imagediff/image_diff_png.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 "build/build_config.h"
-#include "webkit/support/webkit_support_gfx.h"
+#include "tools/imagediff/image_diff_png.h"
 
 #include <stdlib.h>
 #include <string.h>
 
+#include "base/logging.h"
+#include "build/build_config.h"
 #include "third_party/libpng/png.h"
 #include "third_party/zlib/zlib.h"
 
-namespace webkit_support {
+namespace image_diff_png {
 
-// Define macro here to make webkit_support_gfx independent of target base.
-// Note that the NOTREACHED() macro will result in a crash. This is preferable
-// to calling exit() / abort(), since the latter may not surfce the problem as
-// crash reports, making it hard to tell where the problem is.
-#define NOTREACHED(msg) *((volatile int*)0) = 3
-#define DCHECK(condition) \
-  if (!(condition)) fprintf(stderr, "DCHECK failed: " #condition ".")
-
-// The new webkit_support_gfx, used by DumpRenderTree and ImageDiff,
-// doesn't depend on most other parts of chromium. This could make building
-// the individual target of ImageDiff fast. It's implemented by duplicating
-// most code in ui/gfx/codec/png_codec.cc, after removing code related to
-// Skia.
+// This is a duplicate of ui/gfx/codec/png_codec.cc, after removing code related
+// to Skia, that we can use when running layout tests with minimal dependencies.
 namespace {
 
 enum ColorFormat {
   // 3 bytes per pixel (packed), in RGB order regardless of endianness.
   // This is the native JPEG format.
   FORMAT_RGB,
 
   // 4 bytes per pixel, in RGBA order in memory regardless of endianness.
   FORMAT_RGBA,
 
@@ skipping 189 matching lines @@
         break;
       case FORMAT_RGBA:
         state->row_converter = &ConvertRGBtoRGBA;
         state->output_channels = 4;
         break;
       case FORMAT_BGRA:
         state->row_converter = &ConvertRGBtoBGRA;
         state->output_channels = 4;
         break;
       default:
-        NOTREACHED("Unknown output format");
+        NOTREACHED() << "Unknown output format";
         break;
     }
   } else if (channels == 4) {
     switch (state->output_format) {
       case FORMAT_RGB:
         state->row_converter = &ConvertRGBAtoRGB;
         state->output_channels = 3;
         break;
       case FORMAT_RGBA:
         state->row_converter = NULL;  // no conversion necessary
         state->output_channels = 4;
         break;
       case FORMAT_BGRA:
         state->row_converter = &ConvertBetweenBGRAandRGBA;
         state->output_channels = 4;
         break;
       default:
-        NOTREACHED("Unknown output format");
+        NOTREACHED() << "Unknown output format";
         break;
     }
   } else {
-    NOTREACHED("Unknown input channels");
+    NOTREACHED() << "Unknown input channels";
     longjmp(png_jmpbuf(png_ptr), 1);
   }
 
   state->output->resize(
       state->width * state->output_channels * state->height);
 }
 
 void DecodeRowCallback(png_struct* png_ptr, png_byte* new_row,
                        png_uint_32 row_num, int pass) {
   PngDecoderState* state = static_cast<PngDecoderState*>(
       png_get_progressive_ptr(png_ptr));
 
   DCHECK(pass == 0);
   if (static_cast<int>(row_num) > state->height) {
-    NOTREACHED("Invalid row");
+    NOTREACHED() << "Invalid row";
     return;
   }
 
   unsigned char* base = NULL;
   base = &state->output->front();
 
   unsigned char* dest = &base[state->width * state->output_channels * row_num];
   if (state->row_converter)
     state->row_converter(new_row, state->width, dest, &state->is_opaque);
   else
@@ skipping 294 matching lines @@
         png_output_color_type = PNG_COLOR_TYPE_RGB;
         converter = ConvertBGRAtoRGB;
       } else {
         output_color_components = 4;
         png_output_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
         converter = ConvertBetweenBGRAandRGBA;
       }
       break;
 
     default:
-      NOTREACHED("Unknown pixel format");
+      NOTREACHED() << "Unknown pixel format";
       return false;
   }
 
   // Row stride should be at least as long as the length of the data.
   DCHECK(input_color_components * width <= row_byte_width);
 
   png_struct* png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
                                                 NULL, NULL, NULL);
   if (!png_ptr)
     return false;
@@ skipping 63 matching lines @@
                                bool discard_transparency,
                                const std::string& checksum,
                                std::vector<unsigned char>* output) {
   std::vector<Comment> comments;
   comments.push_back(Comment("checksum", checksum));
   return Encode(input, FORMAT_BGRA,
       width, height, row_byte_width, discard_transparency,
       comments, output);
 }
 
-}  // namespace webkit_support
+}  // image_diff_png