Fix for GL_CHROMIUM_flipy in TexSubImage2D

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 
 #include <set>
 #include <queue>
@@ skipping 1551 matching lines @@
       width, 2, format, type, unpack_alignment_, &temp_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
     return;
   }
   GLsizeiptr padded_row_size = temp_size - unpadded_row_size;
   if (padded_row_size < 0 || unpadded_row_size < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
     return;
   }
 
-  GLsizei original_height = height;
+  GLint original_yoffset = yoffset;
   if (padded_row_size <= max_size) {
     // Transfer by rows.
     GLint max_rows = max_size / std::max(padded_row_size,
                                          static_cast<GLsizeiptr>(1));
     while (height) {
       GLint num_rows = std::min(height, max_rows);
       GLsizeiptr part_size =
           (num_rows - 1) * padded_row_size + unpadded_row_size;
       void* buffer = transfer_buffer_.Alloc(part_size);
       GLint y;
       if (unpack_flip_y_) {
         CopyRectToBufferFlipped(
             source, width, num_rows, format, type, buffer);
         // GPU_DCHECK(copy_success);  // can't check this because bot fails!
-        y = original_height - yoffset - num_rows;
+        y = original_yoffset + height - num_rows;
       } else {
         memcpy(buffer, source, part_size);
         y = yoffset;
       }
       helper_->TexSubImage2D(
           target, level, xoffset, y, width, num_rows, format, type,
           transfer_buffer_id_, transfer_buffer_.GetOffset(buffer), internal);
       transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
       yoffset += num_rows;
       source += num_rows * padded_row_size;
       height -= num_rows;
     }
   } else {
     // Transfer by sub rows. Because GL has no maximum texture dimensions.
     uint32 temp;
     GLES2Util::ComputeImageDataSize(
        1, 1, format, type, unpack_alignment_, &temp);
     GLsizeiptr element_size = temp;
     max_size -= max_size % element_size;
     GLint max_sub_row_pixels = max_size / element_size;
     for (; height; --height) {
       GLint temp_width = width;
       GLint temp_xoffset = xoffset;
       const int8* row_source = source;
       while (temp_width) {
         GLint num_pixels = std::min(width, max_sub_row_pixels);
         GLsizeiptr part_size = num_pixels * element_size;
         void* buffer = transfer_buffer_.Alloc(part_size);
         memcpy(buffer, row_source, part_size);
-        GLint y = unpack_flip_y_ ? (original_height - yoffset - 1) : yoffset;
+        GLint y = unpack_flip_y_ ? (original_yoffset + height - 1) : yoffset;
         helper_->TexSubImage2D(
             target, level, temp_xoffset, y, num_pixels, 1, format, type,
             transfer_buffer_id_, transfer_buffer_.GetOffset(buffer), internal);
         transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
         row_source += part_size;
         temp_xoffset += num_pixels;
         temp_width -= num_pixels;
       }
       ++yoffset;
       source += padded_row_size;
@@ skipping 1032 matching lines @@
   helper_->PostSubBufferCHROMIUM(x, y, width, height);
   helper_->CommandBufferHelper::Flush();
   if (swap_buffers_tokens_.size() > kMaxSwapBuffers + 1) {
     helper_->WaitForToken(swap_buffers_tokens_.front());
     swap_buffers_tokens_.pop();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu