Implement CompositorCC::ReadPixels

ui/gfx/compositor/compositor_gl.cc

 // Copyright (c) 2011 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/compositor/compositor_gl.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 543 matching lines @@
   if (debug_overdraw)
     glBlendFunc(GL_ONE, GL_ONE);
   else
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 CompositorGL::~CompositorGL() {
   gl_context_ = NULL;
 }
 
-void CompositorGL::ReadPixels(SkBitmap* bitmap) {
+bool CompositorGL::ReadPixels(SkBitmap* bitmap) {
   MakeCurrent();
 
   bitmap->setConfig(SkBitmap::kARGB_8888_Config,
                     size().width(),
                     size().height());
   bitmap->allocPixels();
   SkAutoLockPixels lock(*bitmap);
   unsigned char* pixels = static_cast<unsigned char*>(bitmap->getPixels());
 
   // Check that it's a tight pixel packing
   DCHECK_EQ(bitmap->rowBytes(),
             SkBitmap::ComputeRowBytes(bitmap->config(), bitmap->width()));
 
   GLint current_alignment = 0;
   glGetIntegerv(GL_PACK_ALIGNMENT, &current_alignment);
   glPixelStorei(GL_PACK_ALIGNMENT, 4);
   glReadPixels(0,
                0,
                size().width(),
                size().height(),
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                pixels);
   glPixelStorei(GL_PACK_ALIGNMENT, current_alignment);
 
-  // Swizzle from RGBA to BGRA
-  size_t bitmap_size = 4 * size().width() * size().height();
-  for(size_t i = 0; i < bitmap_size; i += 4)
-    std::swap(pixels[i], pixels[i + 2]);
-
-  // Vertical flip to transform from GL co-ords
-  size_t row_size = 4 * size().width();
-  scoped_array<unsigned char> tmp_row(new unsigned char[row_size]);
-  for(int row = 0; row < size().height() / 2; row++) {
-    memcpy(tmp_row.get(),
-           &pixels[row * row_size],
-           row_size);
-    memcpy(&pixels[row * row_size],
-           &pixels[bitmap_size - (row + 1) * row_size],
-           row_size);
-    memcpy(&pixels[bitmap_size - (row + 1) * row_size],
-           tmp_row.get(),
-           row_size);
-  }
+  SwizzleRGBAToBGRAAndFlip(pixels, size());
+  return true;
 }
 
 void CompositorGL::MakeCurrent() {
   gl_context_->MakeCurrent(gl_surface_.get());
 }
 
 void CompositorGL::OnWidgetSizeChanged() {
 }
 
 Texture* CompositorGL::CreateTexture() {
@@ skipping 37 matching lines @@
 Compositor* Compositor::Create(CompositorDelegate* owner,
                                gfx::AcceleratedWidget widget,
                                const gfx::Size& size) {
   if (SharedResourcesGL::GetInstance() == NULL)
     return NULL;
   else
     return new CompositorGL(owner, widget, size);
 }
 
 }  // namespace ui