Move SharedMemoryLimits out of WebGraphicsContext3DCommandBufferImpl.

gpu/command_buffer/client/mapped_memory.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.
 
 #include "gpu/command_buffer/client/mapped_memory.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 
 #include "base/atomic_sequence_num.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
+#include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/common/buffer.h"
 
 namespace gpu {
 namespace {
 
 // Generates process-unique IDs to use for tracing a MappedMemoryManager's
 // chunks.
 base::StaticAtomicSequenceNumber g_next_mapped_memory_manager_tracing_id;
 
 }  // namespace
 
 MemoryChunk::MemoryChunk(int32_t shm_id,
                          scoped_refptr<gpu::Buffer> shm,
                          CommandBufferHelper* helper)
     : shm_id_(shm_id),
       shm_(shm),
       allocator_(shm->size(), helper, shm->memory()) {}
 
 MemoryChunk::~MemoryChunk() {}
 
 MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper,
                                          size_t unused_memory_reclaim_limit)
     : chunk_size_multiple_(FencedAllocator::kAllocAlignment),
       helper_(helper),
       allocated_memory_(0),
       max_free_bytes_(unused_memory_reclaim_limit),
-      max_allocated_bytes_(kNoLimit),
+      max_allocated_bytes_(SharedMemoryLimits::kNoLimit),
       tracing_id_(g_next_mapped_memory_manager_tracing_id.GetNext()) {
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
         this, "gpu::MappedMemoryManager", base::ThreadTaskRunnerHandle::Get());
   }
 }
 
@@ skipping 23 matching lines @@
         DCHECK(mem);
         *shm_id = chunk->shm_id();
         *shm_offset = chunk->GetOffset(mem);
         return mem;
       }
     }
 
     // If there is a memory limit being enforced and total free
     // memory (allocated_memory_ - total_bytes_in_use) is larger than
     // the limit try waiting.
-    if (max_free_bytes_ != kNoLimit &&
+    if (max_free_bytes_ != SharedMemoryLimits::kNoLimit &&
         (allocated_memory_ - total_bytes_in_use) >= max_free_bytes_) {
       TRACE_EVENT0("gpu", "MappedMemoryManager::Alloc::wait");
       for (auto& chunk : chunks_) {
         if (chunk->GetLargestFreeSizeWithWaiting() >= size) {
           void* mem = chunk->Alloc(size);
           DCHECK(mem);
           *shm_id = chunk->shm_id();
           *shm_offset = chunk->GetOffset(mem);
           return mem;
         }
       }
     }
   }
 
-  if (max_allocated_bytes_ != kNoLimit &&
+  if (max_allocated_bytes_ != SharedMemoryLimits::kNoLimit &&
       (allocated_memory_ + size) > max_allocated_bytes_) {
     return nullptr;
   }
 
   // Make a new chunk to satisfy the request.
   CommandBuffer* cmd_buf = helper_->command_buffer();
   unsigned int chunk_size =
       ((size + chunk_size_multiple_ - 1) / chunk_size_multiple_) *
       chunk_size_multiple_;
   int32_t id = -1;
@@ skipping 94 matching lines @@
 void ScopedMappedMemoryPtr::Reset(uint32_t new_size) {
   Release();
 
   if (new_size) {
     buffer_ = mapped_memory_manager_->Alloc(new_size, &shm_id_, &shm_offset_);
     size_ = buffer_ ? new_size : 0;
   }
 }
 
 }  // namespace gpu