Remove flip_y, premultiply_alpha, unmultiply_alpha support in command buffer.

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
@@ skipping 60 matching lines @@
     bool bind_generates_resource,
     bool lose_context_when_out_of_memory,
     bool support_client_side_arrays,
     GpuControl* gpu_control)
     : helper_(helper),
       transfer_buffer_(transfer_buffer),
       angle_pack_reverse_row_order_status_(kUnknownExtensionStatus),
       chromium_framebuffer_multisample_(kUnknownExtensionStatus),
       pack_alignment_(4),
       unpack_alignment_(4),
-      unpack_flip_y_(false),
       unpack_row_length_(0),
       unpack_image_height_(0),
       unpack_skip_rows_(0),
       unpack_skip_pixels_(0),
       unpack_skip_images_(0),
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_read_framebuffer_(0),
       bound_renderbuffer_(0),
@@ skipping 1502 matching lines @@
     case GL_UNPACK_SKIP_ROWS_EXT:
         unpack_skip_rows_ = param;
         return;
     case GL_UNPACK_SKIP_PIXELS_EXT:
         unpack_skip_pixels_ = param;
         return;
     case GL_UNPACK_SKIP_IMAGES:
         unpack_skip_images_ = param;
         return;
     case GL_UNPACK_FLIP_Y_CHROMIUM:
-        unpack_flip_y_ = (param != 0);
-        break;
+    case GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM:
+    case GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM:
+        // TODO(zmo): Remove this when blink side callers are removed.
+        return;
     case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
         pack_reverse_row_order_ =
             IsAnglePackReverseRowOrderAvailable() ? (param != 0) : false;
         break;
     default:
         break;
   }
   helper_->PixelStorei(pname, param);
   CheckGLError();
 }
@@ skipping 475 matching lines @@
   CheckGLError();
 }
 
 namespace {
 
 void CopyRectToBuffer(
     const void* pixels,
     uint32 height,
     uint32 unpadded_row_size,
     uint32 pixels_padded_row_size,
-    bool flip_y,
     void* buffer,
     uint32 buffer_padded_row_size) {
   const int8* source = static_cast<const int8*>(pixels);
   int8* dest = static_cast<int8*>(buffer);
-  if (flip_y || pixels_padded_row_size != buffer_padded_row_size) {
-    if (flip_y) {
-      dest += buffer_padded_row_size * (height - 1);
-    }
+  if (pixels_padded_row_size != buffer_padded_row_size) {
     // the last row is copied unpadded at the end
     for (; height > 1; --height) {
       memcpy(dest, source, buffer_padded_row_size);
-      if (flip_y) {
-        dest -= buffer_padded_row_size;
-      } else {
-        dest += buffer_padded_row_size;
-      }
+      dest += buffer_padded_row_size;
       source += pixels_padded_row_size;
     }
     memcpy(dest, source, unpadded_row_size);
   } else {
     uint32 size = (height - 1) * pixels_padded_row_size + unpadded_row_size;
     memcpy(dest, source, size);
   }
 }
 
 }  // anonymous namespace
@@ skipping 96 matching lines @@
 
       mapped_alloc.SetFlushAfterRelease(true);
       shm_id = mapped_alloc.shm_id();
       shm_offset = mapped_alloc.offset();
       buffer_pointer = mapped_alloc.address();
     }
   }
 
   if (buffer_pointer) {
     CopyRectToBuffer(
-        pixels, height, unpadded_row_size, src_padded_row_size, unpack_flip_y_,
+        pixels, height, unpadded_row_size, src_padded_row_size,
         buffer_pointer, padded_row_size);
     helper_->TexImage2D(
         target, level, internalformat, width, height, format, type,
         shm_id, shm_offset);
     CheckGLError();
     return;
   }
 
   // No, so send it using TexSubImage2D.
   helper_->TexImage2D(
@@ skipping 108 matching lines @@
       shm_offset = mapped_alloc.offset();
       buffer_pointer = mapped_alloc.address();
     }
   }
 
   if (buffer_pointer) {
     for (GLsizei z = 0; z < depth; ++z) {
       // Only the last row of the last image is unpadded.
       uint32 src_unpadded_row_size =
           (z == depth - 1) ? unpadded_row_size : src_padded_row_size;
-      // TODO(zmo): Ignore flip_y flag for now.
       CopyRectToBuffer(
-          pixels, height, src_unpadded_row_size, src_padded_row_size, false,
+          pixels, height, src_unpadded_row_size, src_padded_row_size,
           buffer_pointer, padded_row_size);
       pixels = reinterpret_cast<const int8*>(pixels) +
           src_padded_row_size * src_height;
       buffer_pointer = reinterpret_cast<int8*>(buffer_pointer) +
           padded_row_size * height;
     }
     helper_->TexImage3D(
         target, level, internalformat, width, height, depth, format, type,
         shm_id, shm_offset);
     CheckGLError();
@@ skipping 189 matching lines @@
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, uint32 unpadded_row_size,
     const void* pixels, uint32 pixels_padded_row_size, GLboolean internal,
     ScopedTransferBufferPtr* buffer, uint32 buffer_padded_row_size) {
   DCHECK(buffer);
   DCHECK_GE(level, 0);
   DCHECK_GT(height, 0);
   DCHECK_GT(width, 0);
 
   const int8* source = reinterpret_cast<const int8*>(pixels);
-  GLint original_yoffset = yoffset;
   // Transfer by rows.
   while (height) {
     unsigned int desired_size =
         buffer_padded_row_size * (height - 1) + unpadded_row_size;
     if (!buffer->valid() || buffer->size() == 0) {
       buffer->Reset(desired_size);
       if (!buffer->valid()) {
         return;
       }
     }
 
     GLint num_rows = ComputeNumRowsThatFitInBuffer(
         buffer_padded_row_size, unpadded_row_size, buffer->size(), height);
     num_rows = std::min(num_rows, height);
     CopyRectToBuffer(
         source, num_rows, unpadded_row_size, pixels_padded_row_size,
-        unpack_flip_y_, buffer->address(), buffer_padded_row_size);
-    GLint y = unpack_flip_y_ ? original_yoffset + height - num_rows : yoffset;
+        buffer->address(), buffer_padded_row_size);
     helper_->TexSubImage2D(
-        target, level, xoffset, y, width, num_rows, format, type,
+        target, level, xoffset, yoffset, width, num_rows, format, type,
         buffer->shm_id(), buffer->offset(), internal);
     buffer->Release();
     yoffset += num_rows;
     source += num_rows * pixels_padded_row_size;
     height -= num_rows;
   }
 }
 
 void GLES2Implementation::TexSubImage3DImpl(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei zoffset,
@@ skipping 43 matching lines @@
     GLsizei my_height, my_depth;
     if (num_images > 0) {
       num_rows = num_images * height;
       my_height = height;
       my_depth = num_images;
     } else {
       my_height = num_rows;
       my_depth = 1;
     }
 
-    // TODO(zmo): Ignore flip_y flag for now.
     if (num_images > 0) {
       int8* buffer_pointer = reinterpret_cast<int8*>(buffer->address());
       uint32 src_height =
           unpack_image_height_ > 0 ? unpack_image_height_ : height;
       uint32 image_size_dst = buffer_padded_row_size * height;
       uint32 image_size_src = pixels_padded_row_size * src_height;
       for (GLint ii = 0; ii < num_images; ++ii) {
         uint32 my_unpadded_row_size;
         if (total_rows == num_rows && ii + 1 == num_images)
           my_unpadded_row_size = unpadded_row_size;
         else
           my_unpadded_row_size = pixels_padded_row_size;
         CopyRectToBuffer(
             source + ii * image_size_src, my_height, my_unpadded_row_size,
-            pixels_padded_row_size, false, buffer_pointer + ii * image_size_dst,
+            pixels_padded_row_size, buffer_pointer + ii * image_size_dst,
             buffer_padded_row_size);
       }
     } else {
       uint32 my_unpadded_row_size;
       if (total_rows == num_rows)
         my_unpadded_row_size = unpadded_row_size;
       else
         my_unpadded_row_size = pixels_padded_row_size;
       CopyRectToBuffer(
           source, my_height, my_unpadded_row_size, pixels_padded_row_size,
-          false, buffer->address(), buffer_padded_row_size);
+          buffer->address(), buffer_padded_row_size);
     }
     helper_->TexSubImage3D(
         target, level, xoffset, yoffset + row_index, zoffset + depth_index,
         width, my_height, my_depth,
         format, type, buffer->shm_id(), buffer->offset(), internal);
     buffer->Release();
 
     total_rows -= num_rows;
     if (total_rows > 0) {
       GLint num_image_paddings;
@@ skipping 418 matching lines @@
   const char* result = NULL;
   // Clears the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetString(name, kResultBucketId);
   std::string str;
   if (GetBucketAsString(kResultBucketId, &str)) {
     // Adds extensions implemented on client side only.
     switch (name) {
       case GL_EXTENSIONS:
         str += std::string(str.empty() ? "" : " ") +
-            "GL_CHROMIUM_flipy "
             "GL_EXT_unpack_subimage "
             "GL_CHROMIUM_map_sub";
         if (capabilities_.image)
           str += " GL_CHROMIUM_image GL_CHROMIUM_gpu_memory_buffer_image";
         if (capabilities_.future_sync_points)
           str += " GL_CHROMIUM_future_sync_point";
         break;
       default:
         break;
     }
@@ skipping 2664 matching lines @@
   CheckGLError();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu