[Experiment] purge-and-suspend

cc/raster/staging_buffer_pool.cc

 // Copyright 2016 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 "cc/raster/staging_buffer_pool.h"
 
 #include <memory>
 
+#include "base/allocator/allocator_extension.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/base/container_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 
 namespace cc {
@@ skipping 115 matching lines @@
       free_staging_buffer_usage_in_bytes_(0),
       staging_buffer_expiration_delay_(
           base::TimeDelta::FromMilliseconds(kStagingBufferExpirationDelayMs)),
       reduce_memory_usage_pending_(false),
       weak_ptr_factory_(this) {
   DCHECK(worker_context_provider_);
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "cc::StagingBufferPool", base::ThreadTaskRunnerHandle::Get());
   reduce_memory_usage_callback_ = base::Bind(
       &StagingBufferPool::ReduceMemoryUsage, weak_ptr_factory_.GetWeakPtr());
+
+  memory_pressure_listener_.reset(new base::MemoryPressureListener(base::Bind(
+      &StagingBufferPool::OnMemoryPressure, base::Unretained(this))));
 }
 
 StagingBufferPool::~StagingBufferPool() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 void StagingBufferPool::Shutdown() {
   base::AutoLock lock(lock_);
   if (buffers_.empty())
@@ skipping 25 matching lines @@
                      [buffer](const std::unique_ptr<StagingBuffer>& b) {
                        return b.get() == buffer;
                      });
     buffer->OnMemoryDump(pmd, buffer->format,
                          in_free_buffers != free_buffers_.end());
   }
 
   return true;
 }
 
+void StagingBufferPool::OnMemoryPressure(
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  base::AutoLock lock(lock_);
+  if (buffers_.empty())
+    return;
+
+  ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max());
+  base::allocator::ReleaseFreeMemory();

[esprehn, 2016/08/05 23:00:57]

is this is very strange inside the cc/raster code... why would StagingBufferPool
call into base::allocator? If we're supposed to do this the MemoryCoordinator
should do it for you automatically after calling the OnMemoryPressure callbacks

[tasak, 2016/08/08 04:47:36]

Acknowledged.

Yeah, I agree that MemoryCoordinator should do. Since we have no
MemoryCoordinator, I temporarily added tons of
base::allocator::ReleaseFreeMemory(). I will revert the bad
base::allocator::ReleaseFreeMemory() calls.

+}
+
 void StagingBufferPool::AddStagingBuffer(const StagingBuffer* staging_buffer,
                                          ResourceFormat format) {
   lock_.AssertAcquired();
 
   DCHECK(buffers_.find(staging_buffer) == buffers_.end());
   buffers_.insert(staging_buffer);
   int buffer_usage_in_bytes =
       ResourceUtil::UncheckedSizeInBytes<int>(staging_buffer->size, format);
   staging_buffer_usage_in_bytes_ += buffer_usage_in_bytes;
 }
@@ skipping 204 matching lines @@
         return;
 
       busy_buffers_.front()->DestroyGLResources(gl);
       RemoveStagingBuffer(busy_buffers_.front().get());
       busy_buffers_.pop_front();
     }
   }
 }
 
 }  // namespace cc