Enforce a memory limit on MappedMemoryManager

gpu/command_buffer/client/mapped_memory.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_
 #define GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_
 
 #include "base/memory/scoped_vector.h"
 #include "gpu/command_buffer/client/fenced_allocator.h"
 #include "gpu/command_buffer/common/buffer.h"
@@ skipping 61 matching lines @@
   // Frees a block of memory, pending the passage of a token. That memory won't
   // be re-allocated until the token has passed through the command stream.
   //
   // Parameters:
   //   pointer: the pointer to the memory block to free.
   //   token: the token value to wait for before re-using the memory.
   void FreePendingToken(void* pointer, unsigned int token) {
     allocator_.FreePendingToken(pointer, token);
   }
 
-  // Frees any blocks who's tokens have passed.
+  // Frees any blocks whose tokens have passed.
   void FreeUnused() {
     allocator_.FreeUnused();
   }
 
   // Returns true if pointer is in the range of this block.
   bool IsInChunk(void* pointer) const {
     return pointer >= shm_.ptr &&
            pointer < reinterpret_cast<const int8*>(shm_.ptr) + shm_.size;
   }
 
-  // Returns true of any memory in this chuck is in use.
+  // Returns true of any memory in this chunk is in use.
   bool InUse() {
     return allocator_.InUse();
   }
 
  private:
   int32 shm_id_;
   gpu::Buffer shm_;
   FencedAllocatorWrapper allocator_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryChunk);
 };
 
-// Manages MemoryChucks.
+// Manages MemoryChunks.
 class GPU_EXPORT MappedMemoryManager {
  public:
   explicit MappedMemoryManager(CommandBufferHelper* helper);
+  explicit MappedMemoryManager(CommandBufferHelper* helper,

[piman, 2013/08/15 02:49:03]

No explicit. Do we really need 2 constructors? Can we fix callers to always pass
memory_limit?

[kaanb, 2013/08/16 22:50:44]

Removed the explicit. I'd prefer to keep this patch easily mergeable to M30, we
can cleanup the constructors later on. All of them are in unittests except the
one in GLES2Implementation which is already getting modified.

+                               size_t memory_limit);
 
   ~MappedMemoryManager();
 
   unsigned int chunk_size_multiple() const {
     return chunk_size_multiple_;
   }
 
   void set_chunk_size_multiple(unsigned int multiple) {
     chunk_size_multiple_ = multiple;
   }
@@ skipping 24 matching lines @@
 
   // Free Any Shared memory that is not in use.
   void FreeUnused();
 
   // Used for testing
   size_t num_chunks() {
     return chunks_.size();
   }
 
  private:
+  enum MemoryLimit {
+    kNoLimit = 0,
+  };
   typedef ScopedVector<MemoryChunk> MemoryChunkVector;
 
   // size a chunk is rounded up to.
   unsigned int chunk_size_multiple_;
   CommandBufferHelper* helper_;
   MemoryChunkVector chunks_;
+  size_t allocated_memory_;
+  size_t memory_limit_;
 
   DISALLOW_COPY_AND_ASSIGN(MappedMemoryManager);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_