Move the JPEG and PNG codecs from base/gfx to app/gfx/codec. Move the classes...

tools/imagediff/image_diff.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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.
 
 // This file input format is based loosely on
 // WebKitTools/DumpRenderTree/ImageDiff.m
 
 // The exact format of this tool's output to stdout is important, to match
 // what the run-webkit-tests script expects.
 
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <iostream>
 
+#include "app/gfx/codec/png_codec.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
-#include "base/gfx/png_decoder.h"
-#include "base/gfx/png_encoder.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 
 #if defined(OS_WIN)
 #include "windows.h"
 #endif
 
 // Causes the app to remain open, waiting for pairs of filenames on stdin.
@@ skipping 40 matching lines @@
   // Creates the image from stdin with the given data length. On success, it
   // will return true. On failure, no other methods should be accessed.
   bool CreateFromStdin(size_t byte_length) {
     if (byte_length == 0)
       return false;
 
     scoped_array<unsigned char> source(new unsigned char[byte_length]);
     if (fread(source.get(), 1, byte_length, stdin) != byte_length)
       return false;
 
-    if (!PNGDecoder::Decode(source.get(), byte_length, PNGDecoder::FORMAT_RGBA,
-                          &data_, &w_, &h_)) {
+    if (!gfx::PNGCodec::Decode(source.get(), byte_length,
+                               gfx::PNGCodec::FORMAT_RGBA,
+                               &data_, &w_, &h_)) {
       Clear();
       return false;
     }
     return true;
   }
 
   // Creates the image from the given filename on disk, and returns true on
   // success.
   bool CreateFromFilename(const char* filename) {
     FILE* f = file_util::OpenFile(std::string(filename), "rb");
     if (!f)
       return false;
 
     std::vector<unsigned char> compressed;
     const int buf_size = 1024;
     unsigned char buf[buf_size];
     size_t num_read = 0;
     while ((num_read = fread(buf, 1, buf_size, f)) > 0) {
       std::copy(buf, &buf[num_read], std::back_inserter(compressed));
     }
 
     file_util::CloseFile(f);
 
-    if (!PNGDecoder::Decode(&compressed[0], compressed.size(),
-                          PNGDecoder::FORMAT_RGBA, &data_, &w_, &h_)) {
+    if (!gfx::PNGCodec::Decode(&compressed[0], compressed.size(),
+                               gfx::PNGCodec::FORMAT_RGBA, &data_, &w_, &h_)) {
       Clear();
       return false;
     }
     return true;
   }
 
   void Clear() {
     w_ = h_ = 0;
     data_.clear();
   }
@@ skipping 183 matching lines @@
     fprintf(stderr, "image_diff: Unable to open file \"%s\"\n", file2);
     return kStatusError;
   }
 
   Image diff_image;
   bool same = CreateImageDiff(baseline_image, actual_image, &diff_image);
   if (same)
     return kStatusSame;
 
   std::vector<unsigned char> png_encoding;
-  PNGEncoder::Encode(diff_image.data(),  PNGEncoder::FORMAT_RGBA,
-                     diff_image.w(), diff_image.h(), diff_image.w() * 4,
-                     false, &png_encoding);
+  gfx::PNGCodec::Encode(diff_image.data(), gfx::PNGCodec::FORMAT_RGBA,
+                        diff_image.w(), diff_image.h(), diff_image.w() * 4,
+                        false, &png_encoding);
   if (file_util::WriteFile(UTF8ToWide(out_file),
       reinterpret_cast<char*>(&png_encoding.front()), png_encoding.size()) < 0)
     return kStatusError;
 
   return kStatusDifferent;
 }
 
 int main(int argc, const char* argv[]) {
   base::EnableTerminationOnHeapCorruption();
   CommandLine::Init(argc, argv);
@@ skipping 31 matching lines @@
                         WideToUTF8(values[1]).c_str(),
                         WideToUTF8(values[2]).c_str());
     }
   } else if (values.size() == 2) {
     return CompareImages(argv[1], argv[2]);
   }
 
   PrintHelp();
   return kStatusError;
 }