Update Context Client Visibility to use Scoped Pattern

gpu/command_buffer/client/gles2_implementation.cc

 // 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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <map>
 #include <set>
 #include <sstream>
 #include <string>
 #include "base/atomic_sequence_num.h"
 #include "base/compiler_specific.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/client/buffer_tracker.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
@@ skipping 12 matching lines @@
 #if defined(GPU_CLIENT_DEBUG)
 #include "base/command_line.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
+// Class that DCHECKs if it is destructed without first having Release called.
+class ScopedVisibilityImpl : public ContextSupport::ScopedVisibility {
+ public:
+  explicit ScopedVisibilityImpl(ContextSupport* context_support)
+      : initial_context_support_(context_support) {}
+  ~ScopedVisibilityImpl() { DCHECK(!initial_context_support_); }
+
+  void Release(ContextSupport* context_support) {
+    DCHECK_EQ(initial_context_support_, context_support);
+    initial_context_support_ = nullptr;
+  }
+
+ private:
+  const ContextSupport* initial_context_support_;
+};
+
 void CopyRectToBuffer(const void* pixels,
                       uint32_t height,
                       uint32_t unpadded_row_size,
                       uint32_t pixels_padded_row_size,
                       void* buffer,
                       uint32_t buffer_padded_row_size) {
   if (height == 0)
     return;
   const int8_t* source = static_cast<const int8_t*>(pixels);
   int8_t* dest = static_cast<int8_t*>(buffer);
@@ skipping 93 matching lines @@
           // Do not use more than 5% of extra shared memory, and do not
           // use any extra for memory contrained devices (<=1GB).
           base::SysInfo::AmountOfPhysicalMemory() > 1024 * 1024 * 1024
               ? base::saturated_cast<uint32_t>(
                     base::SysInfo::AmountOfPhysicalMemory() / 20)
               : 0),
 #endif
       current_trace_stack_(0),
       gpu_control_(gpu_control),
       capabilities_(gpu_control->GetCapabilities()),
-      aggressively_free_resources_(false),
       cached_extension_string_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(helper);
   DCHECK(transfer_buffer);
   DCHECK(gpu_control);
 
   std::stringstream ss;
   ss << std::hex << this;
   this_in_hex_ = ss.str();
 
@@ skipping 227 matching lines @@
   // Flush previously entered commands to ensure ordering with any
   // glBeginQueryEXT() calls that may have been put into the context.
   ShallowFlushCHROMIUM();
   gpu_control_->SignalQuery(
       query,
       base::Bind(&GLES2Implementation::RunIfContextNotLost,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
-void GLES2Implementation::SetAggressivelyFreeResources(
-    bool aggressively_free_resources) {
-  TRACE_EVENT1("gpu", "GLES2Implementation::SetAggressivelyFreeResources",
-               "aggressively_free_resources", aggressively_free_resources);
-  aggressively_free_resources_ = aggressively_free_resources;
+void GLES2Implementation::TrimResources() {
+  TRACE_EVENT0("gpu", "GLES2Implementation::TrimResources");
+
+  // Set aggressively_free_resources_ to true, which will cause us to free
+  // resources when we call Flush or ShallowFlushCHROMIUM below.
+  aggressively_free_resources_ = true;
 
   if (aggressively_free_resources_ && helper_->HaveRingBuffer()) {
     // Ensure that we clean up as much cache memory as possible and fully flush.
     FlushDriverCachesCHROMIUM();
 
     // Flush will delete transfer buffer resources if
     // |aggressively_free_resources_| is true.
     Flush();
   } else {
     ShallowFlushCHROMIUM();
   }
+
+  // If we are not visible, continue freeing resources on subsequent flushes.
+  // This will be set to false once we become visible.
+  aggressively_free_resources_ = !AnyClientsVisible();
 }
 
 bool GLES2Implementation::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   if (!transfer_buffer_->HaveBuffer())
     return true;
 
   const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
@@ skipping 5413 matching lines @@
 
 uint64_t GLES2Implementation::ShareGroupTracingGUID() const {
   return share_group_->TracingGUID();
 }
 
 void GLES2Implementation::SetErrorMessageCallback(
     const base::Callback<void(const char*, int32_t)>& callback) {
   error_message_callback_ = callback;
 }
 
-void GLES2Implementation::SetClientVisible(int client_id, bool is_visible) {
-  if (is_visible) {
-    visible_clients_.insert(client_id);
-  } else {
-    auto found = visible_clients_.find(client_id);
-    if (found != visible_clients_.end())
-      visible_clients_.erase(found);
-  }
+std::unique_ptr<ContextSupport::ScopedVisibility>
+GLES2Implementation::ClientBecameVisible() {
+  ++num_visible_clients_;
+  // We are visible, ensure that we are no longer freeing resources on flush.
+  aggressively_free_resources_ = false;
+  return base::MakeUnique<ScopedVisibilityImpl>(this);
+}
+
+void GLES2Implementation::ClientBecameNotVisible(
+    std::unique_ptr<ScopedVisibility> visibility) {
+  DCHECK(visibility);
+  DCHECK_GT(num_visible_clients_, 0u);
+  --num_visible_clients_;
+  static_cast<ScopedVisibilityImpl*>(visibility.get())->Release(this);
 }
 
 bool GLES2Implementation::AnyClientsVisible() const {
-  return !visible_clients_.empty();
+  return num_visible_clients_ > 0;
 }
 
 void GLES2Implementation::SetLostContextCallback(
     const base::Closure& callback) {
   lost_context_callback_ = callback;
 }
 
 GLuint64 GLES2Implementation::InsertFenceSyncCHROMIUM() {
   const uint64_t release = gpu_control_->GenerateFenceSyncRelease();
   helper_->InsertFenceSyncCHROMIUM(release);
@@ skipping 1023 matching lines @@
   cached_extensions_.clear();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu