Changes the GLES2Implementation to use a RingBuffer...

gpu/command_buffer/client/gles2_implementation.cc

 // 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.
 
 // A class to emluate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 #include "../common/gles2_cmd_utils.h"
 
 namespace gpu {
@@ skipping 316 matching lines @@
 COMPILE_ASSERT(gpu::kInvalidResource == 0,
                INVALID_RESOURCE_NOT_0_AS_GL_EXPECTS);
 
 GLES2Implementation::GLES2Implementation(
       GLES2CmdHelper* helper,
       size_t transfer_buffer_size,
       void* transfer_buffer,
       int32 transfer_buffer_id)
     : util_(0),  // TODO(gman): Get real number of compressed texture formats.
       helper_(helper),
-      transfer_buffer_(transfer_buffer_size, helper, transfer_buffer),
+      transfer_buffer_(
+          kStartingOffset,
+          transfer_buffer_size - kStartingOffset,
+          helper,
+          static_cast<char*>(transfer_buffer) + kStartingOffset),
       transfer_buffer_id_(transfer_buffer_id),
       pack_alignment_(4),
       unpack_alignment_(4),
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_BUFFERS)
       bound_array_buffer_id_(0),
       bound_element_array_buffer_id_(0),
 #endif
       error_bits_(0) {
   // Allocate space for simple GL results.
-  result_buffer_ = transfer_buffer_.Alloc(kMaxSizeOfSimpleResult);
-  result_shm_offset_ = transfer_buffer_.GetOffset(result_buffer_);
+  result_buffer_ = transfer_buffer;
+  result_shm_offset_ = 0;
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_BUFFERS)
   GLint max_vertex_attribs;
   GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs);
   buffer_id_allocator_.MarkAsUsed(kClientSideArrayId);
   buffer_id_allocator_.MarkAsUsed(kClientSideElementArrayId);
 
   reserved_ids_[0] = kClientSideArrayId;
   reserved_ids_[1] = kClientSideElementArrayId;
 
   client_side_buffer_helper_.reset(new ClientSideBufferHelper(
       max_vertex_attribs,
       kClientSideArrayId,
       kClientSideElementArrayId));
 #endif
 }
 
 GLES2Implementation::~GLES2Implementation() {
   GLuint buffers[] = { kClientSideArrayId, kClientSideElementArrayId, };
   DeleteBuffers(arraysize(buffers), &buffers[0]);
-  transfer_buffer_.Free(result_buffer_);
 }
 
 void GLES2Implementation::MakeIds(
     IdAllocator* id_allocator, GLsizei n, GLuint* ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     ids[ii] = id_allocator->AllocateID();
   }
 }
 
 void GLES2Implementation::FreeIds(
@@ skipping 53 matching lines @@
     uint32 max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
     uint32 offset = 0;
     while (size) {
       uint32 part_size = std::min(max_size, size);
       void* buffer = transfer_buffer_.Alloc(part_size);
       helper_->GetBucketData(
           bucket_id, offset, part_size,
           transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
       WaitForCmd();
       memcpy(&(*data)[offset], buffer, part_size);
-      transfer_buffer_.Free(buffer);
+      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
       offset += part_size;
       size -= part_size;
     }
     // Free the bucket. This is not required but it does free up the memory.
     // and we don't have to wait for the result so from the client's perspective
     // it's cheap.
     helper_->SetBucketSize(bucket_id, 0);
   }
 }
 
@@ skipping 679 matching lines @@
       if (*result == 0) {
         return;
       }
       // We have to copy 1 row at a time to avoid writing pad bytes.
       const int8* src = static_cast<const int8*>(buffer);
       for (GLint yy = 0; yy < num_rows; ++yy) {
         memcpy(dest, src, unpadded_row_size);
         dest += padded_row_size;
         src += padded_row_size;
       }
-      transfer_buffer_.Free(buffer);
+      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
       yoffset += num_rows;
       height -= num_rows;
     }
   } else {
     // Transfer by sub rows. Beacuse GL has no maximum texture dimensions.
     GLES2Util::ComputeImageDataSize(
        1, 1, format, type, pack_alignment_, &temp_size);
     GLsizeiptr element_size = temp_size;
     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;
       int8* row_dest = dest;
       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);
         *result = 0;  // mark as failed.
         helper_->ReadPixels(
             temp_xoffset, yoffset, temp_width, 1, format, type,
             transfer_buffer_id_, transfer_buffer_.GetOffset(buffer),
             result_shm_id(), result_shm_offset());
         WaitForCmd();
         // If it was not marked as successful exit.
         if (*result == 0) {
           return;
         }
         memcpy(row_dest, buffer, part_size);
-        transfer_buffer_.Free(buffer);
+        transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
         row_dest += part_size;
         temp_xoffset += num_pixels;
         temp_width -= num_pixels;
       }
       ++yoffset;
       dest += padded_row_size;
     }
   }
 }
 
@@ skipping 145 matching lines @@
   helper_->GetVertexAttribiv(
       index, pname, result_shm_id(), result_shm_offset());
   WaitForCmd();
   result->CopyResult(params);
 }
 
 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_BUFFERS)
 
 }  // namespace gles2
 }  // namespace gpu