Refactor client visibility handling

blimp/client/support/compositor/blimp_context_provider.cc

 // Copyright 2015 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 "blimp/client/support/compositor/blimp_context_provider.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
+#include "cc/output/context_cache_controller.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/skia_bindings/grcontext_for_gles2_interface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 
 namespace blimp {
 namespace client {
@@ skipping 21 matching lines @@
   attribs_for_gles2.context_type = gpu::gles2::CONTEXT_TYPE_OPENGLES2;
   attribs_for_gles2.lose_context_when_out_of_memory = true;
 
   context_.reset(gpu::GLInProcessContext::Create(
       nullptr /* service */, nullptr /* surface */,
       widget == gfx::kNullAcceleratedWidget /* is_offscreen */, widget,
       nullptr /* share_context */, attribs_for_gles2, gpu::SharedMemoryLimits(),
       gpu_memory_buffer_manager, nullptr /* memory_limits */));
   context_->GetImplementation()->SetLostContextCallback(
       base::Bind(&BlimpContextProvider::OnLostContext, base::Unretained(this)));
+
+  cache_controller_.reset(
+      new cc::ContextCacheController(context_->GetImplementation()));
 }
 
 BlimpContextProvider::~BlimpContextProvider() {
   DCHECK(main_thread_checker_.CalledOnValidThread() ||
          context_thread_checker_.CalledOnValidThread());
 }
 
 bool BlimpContextProvider::BindToCurrentThread() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   return true;
@@ skipping 18 matching lines @@
   return context_->GetImplementation();
 }
 
 class GrContext* BlimpContextProvider::GrContext() {
   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());
+  return gr_context_->get();
+}
 
-  return gr_context_->get();
+cc::ContextCacheController* BlimpContextProvider::CacheController() {
+  DCHECK(context_thread_checker_.CalledOnValidThread());
+  return cache_controller_.get();
 }
 
 void BlimpContextProvider::InvalidateGrContext(uint32_t state) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (gr_context_)
     gr_context_->ResetContext(state);
 }
 
 base::Lock* BlimpContextProvider::GetLock() {
   // This context provider is not used on multiple threads.
   NOTREACHED();
   return nullptr;
 }
 
-void BlimpContextProvider::DeleteCachedResources() {
-  DCHECK(context_thread_checker_.CalledOnValidThread());
-
-  if (gr_context_)
-    gr_context_->FreeGpuResources();
-}
-
 void BlimpContextProvider::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   lost_context_callback_ = lost_context_callback;
 }
 
 void BlimpContextProvider::OnLostContext() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   if (!lost_context_callback_.is_null())
     lost_context_callback_.Run();
   if (gr_context_)
     gr_context_->OnLostContext();
 }
 
 }  // namespace client
 }  // namespace blimp