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 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:
+  // |initial_context_support_| is just stored/used for sanity-checking Release.

[danakj, 2016/08/19 18:29:55]

Update comment

[ericrk, 2016/08/19 18:49:58]

Done.

+  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 5676 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_;
+  return base::MakeUnique<ScopedVisibilityImpl>(this);
+}
+
+void GLES2Implementation::ClientBecameNotVisible(
+    std::unique_ptr<ScopedVisibility> visibility) {
+  DCHECK_GT(num_visible_clients_, 0u);

[danakj, 2016/08/19 18:29:55]

can you DCHECK(visibility) too? (same for the TestContextSupport I guess also)

[ericrk, 2016/08/19 18:49:58]

Done.

+  --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