Make command buffer free transfer buffer when switching tabs

gpu/command_buffer/client/gles2_implementation.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 
 #include <GLES2/gl2.h>
 
 #include <map>
@@ skipping 58 matching lines @@
         (ptr[0] == static_cast<type>(0) || ptr[0] == static_cast<type>(-1)));
 
 namespace gpu {
 
 class MappedMemoryManager;
 
 namespace gles2 {
 
 class ClientSideBufferHelper;
 class ProgramInfoManager;
+class AlignedRingBuffer;
 
 // Base class for IdHandlers
 class IdHandlerInterface {
  public:
   IdHandlerInterface() { }
   virtual ~IdHandlerInterface() { }
 
   // Makes some ids at or above id_offset.
   virtual void MakeIds(GLuint id_offset, GLsizei n, GLuint* ids) = 0;
 
   // Frees some ids.
   virtual bool FreeIds(GLsizei n, const GLuint* ids) = 0;
 
   // Marks an id as used for glBind functions. id = 0 does nothing.
   virtual bool MarkAsUsedForBind(GLuint id) = 0;
 };
 
+// Wraps RingBufferWrapper to provide aligned allocations.
+class AlignedRingBuffer : public RingBufferWrapper {
+ public:
+  AlignedRingBuffer(
+      unsigned int alignment,
+      int32 shm_id,
+      RingBuffer::Offset base_offset,
+      unsigned int size,
+      CommandBufferHelper* helper,
+      void* base)
+      : RingBufferWrapper(base_offset, size, helper, base),
+        alignment_(alignment),
+        shm_id_(shm_id) {
+  }
+  ~AlignedRingBuffer();
+
+  // Overrriden from RingBufferWrapper
+  void* Alloc(unsigned int size) {
+    return RingBufferWrapper::Alloc(RoundToAlignment(size));
+  }
+
+  template <typename T>T* AllocTyped(unsigned int count) {
+    return static_cast<T*>(Alloc(count * sizeof(T)));
+  }
+
+  int32 GetShmId() const {
+    return shm_id_;
+  }
+
+ private:
+  unsigned int RoundToAlignment(unsigned int size) {
+    return (size + alignment_ - 1) & ~(alignment_ - 1);
+  }
+
+  unsigned int alignment_;
+  int32 shm_id_;
+};
+
+// Manages the transfer buffer.
+class TransferBuffer {
+ public:
+  TransferBuffer(
+      CommandBufferHelper* helper,
+      int32 buffer_id,
+      void* buffer,
+      size_t buffer_size,
+      size_t result_size,
+      unsigned int alignment);
+  ~TransferBuffer();
+
+  AlignedRingBuffer* GetBuffer();
+  int GetShmId();
+  void* GetResultBuffer();
+  int GetResultOffset();
+
+  void Free();
+
+  // This is for unit testing only.
+  bool HaveBuffer() const {
+    return buffer_id_ != 0;
+  }
+
+ private:
+  void AllocateRingBuffer();
+
+  void Setup(int32 buffer_id, void* buffer);
+
+  CommandBufferHelper* helper_;
+  scoped_ptr<AlignedRingBuffer> ring_buffer_;
+  unsigned int buffer_size_;
+  unsigned int result_size_;
+  unsigned int alignment_;
+  int32 buffer_id_;
+  void* result_buffer_;
+  uint32 result_shm_offset_;
+};
+
 // This class emulates GLES2 over command buffers. It can be used by a client
 // program so that the program does not need deal with shared memory and command
 // buffer management. See gl2_lib.h.  Note that there is a performance gain to
 // be had by changing your code to use command buffers directly by using the
 // GLES2CmdHelper but that entails changing your code to use and deal with
 // shared memory and synchronization issues.
 class GLES2Implementation {
  public:
   // Stores client side cached GL state.
   struct GLState {
@@ skipping 87 matching lines @@
     return id;
   }
 
   void FreeTextureId(GLuint id) {
     id_handlers_[id_namespaces::kTextures]->FreeIds(1, &id);
   }
 
   void SetSharedMemoryChunkSizeMultiple(unsigned int multiple);
 
   void FreeUnusedSharedMemory();
+  void FreeEverything();
 
  private:
   // Used to track whether an extension is available
   enum ExtensionStatus {
       kAvailableExtensionStatus,
       kUnavailableExtensionStatus,
       kUnknownExtensionStatus
   };
 
-  // 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
@@ skipping 75 matching lines @@
     }
 
     // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture
     GLuint bound_texture_2d;
 
     // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with
     // glBindTexture
     GLuint bound_texture_cube_map;
   };
 
-  // Gets the shared memory id for the result buffer.
-  uint32 result_shm_id() const {
-    return transfer_buffer_id_;
+  // Gets the value of the result.
+  template <typename T>
+  T GetResultAs() {
+    return static_cast<T>(transfer_buffer_.GetResultBuffer());
   }
 
-  // Gets the shared memory offset for the result buffer.
-  uint32 result_shm_offset() const {
-    return result_shm_offset_;
+  int32 GetResultShmId() {
+    return transfer_buffer_.GetShmId();
   }
 
-  // Gets the value of the result.
-  template <typename T>
-  T GetResultAs() const {
-    return static_cast<T>(result_buffer_);
+  uint32 GetResultShmOffset() {
+    return transfer_buffer_.GetResultOffset();
   }
 
   // Lazily determines if GL_ANGLE_pack_reverse_row_order is available
   bool IsAnglePackReverseRowOrderAvailable();
 
   // Gets the GLError through our wrapper.
   GLenum GetGLError();
 
   // Sets our wrapper for the GLError.
   void SetGLError(GLenum error, const char* msg);
@@ skipping 70 matching lines @@
   bool GetProgramivHelper(GLuint program, GLenum pname, GLint* params);
   bool GetRenderbufferParameterivHelper(
       GLenum target, GLenum pname, GLint* params);
   bool GetShaderivHelper(GLuint shader, GLenum pname, GLint* params);
   bool GetTexParameterfvHelper(GLenum target, GLenum pname, GLfloat* params);
   bool GetTexParameterivHelper(GLenum target, GLenum pname, GLint* params);
 
   GLES2Util util_;
   GLES2CmdHelper* helper_;
   scoped_ptr<IdHandlerInterface> id_handlers_[id_namespaces::kNumIdNamespaces];
-  AlignedRingBuffer transfer_buffer_;
-  int transfer_buffer_id_;
-  void* result_buffer_;
-  uint32 result_shm_offset_;
+  TransferBuffer transfer_buffer_;
   std::string last_error_;
 
   std::queue<int32> swap_buffers_tokens_;
   std::queue<int32> rate_limit_tokens_;
 
   ExtensionStatus angle_pack_reverse_row_order_status;
 
   GLState gl_state_;
 
   // pack alignment as last set by glPixelStorei
@@ skipping 95 matching lines @@
 
 inline bool GLES2Implementation::GetTexParameterivHelper(
     GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_