Adds MapBufferSubData and MapTexSubImage2D....

gpu/command_buffer/client/gles2_implementation.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 
 #include <GLES2/gl2.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "../common/gles2_cmd_utils.h"
 #include "../common/scoped_ptr.h"
 #include "../client/gles2_cmd_helper.h"
 #include "../client/ring_buffer.h"
 
 #define GLES2_SUPPORT_CLIENT_SIDE_BUFFERS 1
 
 namespace gpu {
+
+class MappedMemoryManager;
+
 namespace gles2 {
 
 class ClientSideBufferHelper;
 
 // Base class for IdHandlers
 class IdHandlerInterface {
  public:
   IdHandlerInterface() { }
   virtual ~IdHandlerInterface() { }
 
@@ skipping 106 matching lines @@
       typedef GetVertexAttribiv::Result Result;
       Result* result = GetResultAs<Result*>();
       result->SetNumResults(0);
       helper_->GetVertexAttribiv(
           index, pname, result_shm_id(), result_shm_offset());
       WaitForCmd();
       result->CopyResult(params);
     }
   #endif
 
-   GLuint MakeTextureId() {
-     GLuint id;
-     texture_id_handler_->MakeIds(0, 1, &id);
-     return id;
-   }
+  GLuint MakeTextureId() {
+    GLuint id;
+    texture_id_handler_->MakeIds(0, 1, &id);
+    return id;
+  }
 
-   void FreeTextureId(GLuint id) {
-     texture_id_handler_->FreeIds(1, &id);
-   }
+  void FreeTextureId(GLuint id) {
+    texture_id_handler_->FreeIds(1, &id);
+  }
 
  private:
   // Wraps RingBufferWrapper to provide aligned allocations.
   class AlignedRingBuffer : public RingBufferWrapper {
    public:
     AlignedRingBuffer(RingBuffer::Offset base_offset,
                       unsigned int size,
                       CommandBufferHelper *helper,
                       void *base)
         : RingBufferWrapper(base_offset, size, helper, base) {
     }
 
     static unsigned int RoundToAlignment(unsigned int size) {
       return (size + kAlignment - 1) & ~(kAlignment - 1);
     }
 
     // Overrriden from RingBufferWrapper
     void *Alloc(unsigned int size) {
       return RingBufferWrapper::Alloc(RoundToAlignment(size));
     }
 
     // Overrriden from RingBufferWrapper
     template <typename T> T *AllocTyped(unsigned int count) {
       return static_cast<T *>(Alloc(count * sizeof(T)));
     }
   };
 
+  // Base class for mapped resources.
+  struct MappedResource {
+    MappedResource(GLenum _access, int _shm_id, void* mem, unsigned int offset)
+        : access(_access),
+          shm_id(_shm_id),
+          shm_memory(mem),
+          shm_offset(offset) {
+    }
+
+    // access mode. Currently only GL_WRITE_ONLY is valid
+    GLenum access;
+
+    // Shared memory ID for buffer.
+    int shm_id;
+
+    // Address of shared memory
+    void* shm_memory;
+
+    // Offset of shared memory
+    unsigned int shm_offset;
+  };
+
+  // Used to track mapped textures.
+  struct MappedTexture : public MappedResource {
+    MappedTexture(
+        GLenum access,
+        int shm_id,
+        void* shm_mem,
+        unsigned int shm_offset,
+        GLenum _target,
+        GLint _level,
+        GLint _xoffset,
+        GLint _yoffset,
+        GLsizei _width,
+        GLsizei _height,
+        GLenum _format,
+        GLenum _type)
+        : MappedResource(access, shm_id, shm_mem, shm_offset),
+          target(_target),
+          level(_level),
+          xoffset(_xoffset),
+          yoffset(_yoffset),
+          width(_width),
+          height(_height),
+          format(_format),
+          type(_type) {
+    }
+
+    // These match the arguments to TexSubImage2D.
+    GLenum target;
+    GLint level;
+    GLint xoffset;
+    GLint yoffset;
+    GLsizei width;
+    GLsizei height;
+    GLenum format;
+    GLenum type;
+  };
+
+  // Used to track mapped buffers.
+  struct MappedBuffer : public MappedResource {
+    MappedBuffer(
+        GLenum access,
+        int shm_id,
+        void* shm_mem,
+        unsigned int shm_offset,
+        GLenum _target,
+        GLintptr _offset,
+        GLsizeiptr _size)
+        : MappedResource(access, shm_id, shm_mem, shm_offset),
+          target(_target),
+          offset(_offset),
+          size(_size) {
+    }
+
+    // These match the arguments to BufferSubData.
+    GLenum target;
+    GLintptr offset;
+    GLsizeiptr size;
+  };
+
   // Gets the shared memory id for the result buffer.
   uint32 result_shm_id() const {
     return transfer_buffer_id_;
   }
 
   // Gets the shared memory offset for the result buffer.
   uint32 result_shm_offset() const {
     return result_shm_offset_;
   }
 
@@ skipping 90 matching lines @@
 #endif
 
   // Current GL error bits.
   uint32 error_bits_;
 
   // Map of GLenum to Strings for glGetString.  We need to cache these because
   // the pointer passed back to the client has to remain valid for eternity.
   typedef std::map<uint32, std::string> GLStringMap;
   GLStringMap gl_strings_;
 
+  typedef std::map<const void*, MappedBuffer> MappedBufferMap;
+  MappedBufferMap mapped_buffers_;
+
+  typedef std::map<const void*, MappedTexture> MappedTextureMap;
+  MappedTextureMap mapped_textures_;
+
+  scoped_ptr<MappedMemoryManager> mapped_memory_;
+
   DISALLOW_COPY_AND_ASSIGN(GLES2Implementation);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_