Move ui/gfx/codec/ into its own component.

ui/gfx/codec/chromeos/jpeg_codec_robust_slow.cc

 // Copyright 2015 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/chromeos/codec/jpeg_codec_robust_slow.h"
+#include "ui/gfx//codec/chromeos/jpeg_codec_robust_slow.h"
 
 #include <setjmp.h>
 
 #include <memory>
 
 #include "base/logging.h"
-#include "third_party/skia/include/core/SkBitmap.h"
-#include "third_party/skia/include/core/SkColorPriv.h"
 
 extern "C" {
 // IJG provides robust JPEG decode
 #include "third_party/libjpeg/jpeglib.h"
 }
 
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
+
 namespace gfx {
 
 // Encoder/decoder shared stuff ------------------------------------------------
 
 namespace {
 
 // used to pass error info through the JPEG library
 struct CoderErrorMgr {
   jpeg_error_mgr pub;
   jmp_buf setjmp_buffer;
 };
 
 void ErrorExit(jpeg_common_struct* cinfo) {
-  CoderErrorMgr *err = reinterpret_cast<CoderErrorMgr*>(cinfo->err);
+  CoderErrorMgr* err = reinterpret_cast<CoderErrorMgr*>(cinfo->err);
 
   // Return control to the setjmp point.
   longjmp(err->setjmp_buffer, false);
 }
 
 }  // namespace
 
 // Decoder --------------------------------------------------------------------
 
 namespace {
 
 struct JpegDecoderState {
   JpegDecoderState(const unsigned char* in, size_t len)
-      : input_buffer(in), input_buffer_length(len) {
-  }
+      : input_buffer(in), input_buffer_length(len) {}
 
   const unsigned char* input_buffer;
   size_t input_buffer_length;
 };
 
 // Callback to initialize the source.
 //
 // From the JPEG library:
 //  "Initialize source. This is called by jpeg_read_header() before any data is
 //   actually read. May leave bytes_in_buffer set to 0 (in which case a
@@ skipping 46 matching lines @@
     cinfo->src->next_input_byte += num_bytes;
   }
 }
 
 // Our source doesn't need any cleanup, so this is a NOP.
 //
 // From the JPEG library:
 //  "Terminate source --- called by jpeg_finish_decompress() after all data has
 //   been read to clean up JPEG source manager. NOT called by jpeg_abort() or
 //   jpeg_destroy()."
-void TermSource(j_decompress_ptr cinfo) {
-}
+void TermSource(j_decompress_ptr cinfo) {}
 
 #if !defined(JCS_EXTENSIONS)
 // Converts one row of rgb data to rgba data by adding a fully-opaque alpha
 // value.
 void AddAlpha(const unsigned char* rgb, int pixel_width, unsigned char* rgba) {
   for (int x = 0; x < pixel_width; x++) {
     memcpy(&rgba[x * 4], &rgb[x * 3], 3);
     rgba[x * 4 + 3] = 0xff;
   }
 }
 
 // Converts one row of RGB data to BGRA by reordering the color components and
 // adding alpha values of 0xff.
-void RGBtoBGRA(const unsigned char* bgra, int pixel_width, unsigned char* rgb)
-{
+void RGBtoBGRA(const unsigned char* bgra, int pixel_width, unsigned char* rgb) {
   for (int x = 0; x < pixel_width; x++) {
     const unsigned char* pixel_in = &bgra[x * 3];
     unsigned char* pixel_out = &rgb[x * 4];
     pixel_out[0] = pixel_in[2];
     pixel_out[1] = pixel_in[1];
     pixel_out[2] = pixel_in[0];
     pixel_out[3] = 0xff;
   }
 }
 #endif  // !defined(JCS_EXTENSIONS)
 
 // This class destroys the given jpeg_decompress object when it goes out of
 // scope. It simplifies the error handling in Decode (and even applies to the
 // success case).
 class DecompressDestroyer {
  public:
-  DecompressDestroyer() : cinfo_(NULL) {
-  }
-  ~DecompressDestroyer() {
-    DestroyManagedObject();
-  }
+  DecompressDestroyer() : cinfo_(NULL) {}
+  ~DecompressDestroyer() { DestroyManagedObject(); }
   void SetManagedObject(jpeg_decompress_struct* ci) {
     DestroyManagedObject();
     cinfo_ = ci;
   }
   void DestroyManagedObject() {
     if (cinfo_) {
       jpeg_destroy_decompress(cinfo_);
       cinfo_ = NULL;
     }
   }
+
  private:
   jpeg_decompress_struct* cinfo_;
 };
 
 }  // namespace
 
-bool JPEGCodecRobustSlow::Decode(const unsigned char* input, size_t input_size,
+bool JPEGCodecRobustSlow::Decode(const unsigned char* input,
+                                 size_t input_size,
                                  ColorFormat format,
-                                 std::vector<unsigned char>* output, int* w,
+                                 std::vector<unsigned char>* output,
+                                 int* w,
                                  int* h) {
   jpeg_decompress_struct cinfo;
   DecompressDestroyer destroyer;
   destroyer.SetManagedObject(&cinfo);
   output->clear();
 
   // We set up the normal JPEG error routines, then override error_exit.
   // This must be done before the call to create_decompress.
   CoderErrorMgr errmgr;
   cinfo.err = jpeg_std_error(&errmgr.pub);
@@ skipping 152 matching lines @@
   int data_length = w * h * 4;
 
   SkBitmap* bitmap = new SkBitmap();
   bitmap->allocN32Pixels(w, h);
   memcpy(bitmap->getAddr32(0, 0), &data_vector[0], data_length);
 
   return bitmap;
 }
 
 }  // namespace gfx