Refactor client visibility handling

content/common/gpu/client/context_provider_command_buffer.cc

 // Copyright (c) 2013 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 "content/common/gpu/client/context_provider_command_buffer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "cc/output/context_cache_controller.h"
 #include "cc/output/managed_memory_policy.h"
 #include "content/common/gpu/client/command_buffer_metrics.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_trace_implementation.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
@@ skipping 190 matching lines @@
   }
   set_bind_failed.Reset();
   bind_succeeded_ = true;
 
   gles2_impl_->SetLostContextCallback(
       base::Bind(&ContextProviderCommandBuffer::OnLostContext,
                  // |this| owns the GLES2Implementation which holds the
                  // callback.
                  base::Unretained(this)));
 
+  cache_controller_.reset(new cc::ContextCacheController(gles2_impl_.get()));
+
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGpuClientTracing)) {
     // This wraps the real GLES2Implementation and we should always use this
     // instead when it's present.
     trace_impl_.reset(
         new gpu::gles2::GLES2TraceImplementation(gles2_impl_.get()));
   }
 
   // Do this last once the context is set up.
   std::string type_name =
@@ skipping 29 matching lines @@
 }
 
 class GrContext* ContextProviderCommandBuffer::GrContext() {
   DCHECK(bind_succeeded_);
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (gr_context_)
     return gr_context_->get();
 
   gr_context_.reset(new skia_bindings::GrContextForGLES2Interface(ContextGL()));
+  cache_controller_->SetGrContext(gr_context_->get());
 
   // If GlContext is already lost, also abandon the new GrContext.
   if (gr_context_->get() &&
       ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
     gr_context_->get()->abandonContext();
 
   return gr_context_->get();
 }
 
+cc::ContextCacheController* ContextProviderCommandBuffer::CacheController() {
+  DCHECK(context_thread_checker_.CalledOnValidThread());
+  return cache_controller_.get();
+}
+
 void ContextProviderCommandBuffer::InvalidateGrContext(uint32_t state) {
   if (gr_context_) {
     DCHECK(bind_succeeded_);
     DCHECK(context_thread_checker_.CalledOnValidThread());
     gr_context_->ResetContext(state);
   }
 }
 
 void ContextProviderCommandBuffer::SetDefaultTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> default_task_runner) {
   DCHECK(!bind_succeeded_);
   default_task_runner_ = std::move(default_task_runner);
 }
 
 base::Lock* ContextProviderCommandBuffer::GetLock() {
   DCHECK(support_locking_);
   return &context_lock_;
 }
 
 gpu::Capabilities ContextProviderCommandBuffer::ContextCapabilities() {
   DCHECK(bind_succeeded_);
   DCHECK(context_thread_checker_.CalledOnValidThread());
   // Skips past the trace_impl_ as it doesn't have capabilities.
   return gles2_impl_->capabilities();
 }
 
-void ContextProviderCommandBuffer::DeleteCachedResources() {
-  DCHECK(context_thread_checker_.CalledOnValidThread());
-
-  if (gr_context_)
-    gr_context_->FreeGpuResources();
-}
-
 void ContextProviderCommandBuffer::OnLostContext() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (!lost_context_callback_.is_null())
     lost_context_callback_.Run();
   if (gr_context_)
     gr_context_->OnLostContext();
 
   gpu::CommandBuffer::State state = GetCommandBufferProxy()->GetLastState();
   command_buffer_metrics::UmaRecordContextLost(context_type_, state.error,
                                                state.context_lost_reason);
 }
 
 void ContextProviderCommandBuffer::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   DCHECK(lost_context_callback_.is_null() ||
          lost_context_callback.is_null());
   lost_context_callback_ = lost_context_callback;
 }
 
 }  // namespace content