Update Context Client Visibility to use Scoped Pattern

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 29 matching lines @@
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/draw_polygon.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/raster/scoped_gpu_raster.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
-#include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "media/base/media_switches.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ skipping 77 matching lines @@
     case SkXfermode::kColor_Mode:
       return BLEND_MODE_COLOR;
     case SkXfermode::kLuminosity_Mode:
       return BLEND_MODE_LUMINOSITY;
     default:
       NOTREACHED();
       return BLEND_MODE_NONE;
   }
 }
 
+void UpdateVisibilityForContextProvider(
+    ContextProvider* context_provider,
+    std::unique_ptr<gpu::ContextSupport::ScopedVisibility>* scoped_visibility,
+    bool is_visible) {
+  if (is_visible && *scoped_visibility)

[danakj, 2016/08/18 21:39:44]

These 2 can be combined as is_visible == *scoped_visiblity?

[ericrk, 2016/08/19 17:23:18]

good point

+    return;
+  if (!is_visible && !*scoped_visibility)
+    return;
+
+  gpu::ContextSupport* context_support = context_provider->ContextSupport();
+
+  if (is_visible)
+    *scoped_visibility = context_support->ClientBecameVisible();
+  else
+    context_support->ClientBecameNotVisible(std::move(*scoped_visibility));
+
+  bool aggressively_free_resources = !context_support->AnyClientsVisible();
+  if (aggressively_free_resources)
+    context_provider->DeleteCachedResources();
+  context_support->SetAggressivelyFreeResources(aggressively_free_resources);
+}
+
 // Smallest unit that impact anti-aliasing output. We use this to
 // determine when anti-aliasing is unnecessary.
 const float kAntiAliasingEpsilon = 1.0f / 1024.0f;
 
 // Block or crash if the number of pending sync queries reach this high as
 // something is seriously wrong on the service side if this happens.
 const size_t kMaxPendingSyncQueries = 16;
 }  // anonymous namespace
 
 // Parameters needed to draw a RenderPassDrawQuad.
@@ skipping 252 matching lines @@
 }
 
 GLRenderer::~GLRenderer() {
   while (!pending_async_read_pixels_.empty()) {
     PendingAsyncReadPixels* pending_read =
         pending_async_read_pixels_.back().get();
     pending_read->finished_read_pixels_callback.Cancel();
     pending_async_read_pixels_.pop_back();
   }
 
+  // Set our visibility to false to ensure we clean up context resources.
+  UpdateVisibilityForContextProvider(output_surface_->context_provider(),
+                                     &context_client_visibility_, false);
+
   CleanupSharedObjects();
 }
 
 const RendererCapabilitiesImpl& GLRenderer::Capabilities() const {
   return capabilities_;
 }
 
 bool GLRenderer::CanPartialSwap() {
   auto* context_provider = output_surface_->context_provider();
   return context_provider->ContextCapabilities().post_sub_buffer;
 }
 
 void GLRenderer::DidChangeVisibility() {
   if (visible_) {
     output_surface_->EnsureBackbuffer();
   } else {
     TRACE_EVENT0("cc", "GLRenderer::DidChangeVisibility dropping resources");
     ReleaseRenderPassTextures();
     output_surface_->DiscardBackbuffer();
   }
 
   PrepareGeometry(NO_BINDING);
 
-  // Handle cleanup of resources on the ContextProvider. The compositor
-  // ContextProvider is not shared, so always pass 0 for the client_id.
-  // TODO(crbug.com/487471): Update this when we share compositor
-  // ContextProviders.
-  context_support_->SetClientVisible(0 /* client_id */, visible_);
-  bool aggressively_free_resources = !context_support_->AnyClientsVisible();
-  if (aggressively_free_resources)
-    output_surface_->context_provider()->DeleteCachedResources();
-  context_support_->SetAggressivelyFreeResources(aggressively_free_resources);
+  UpdateVisibilityForContextProvider(output_surface_->context_provider(),
+                                     &context_client_visibility_, visible_);
 }
 
 void GLRenderer::ReleaseRenderPassTextures() { render_pass_textures_.clear(); }
 
 void GLRenderer::DiscardPixels() {
   if (!use_discard_framebuffer_)
     return;
   bool using_default_framebuffer =
       !current_framebuffer_lock_ &&
       output_surface_->capabilities().uses_default_gl_framebuffer;
@@ skipping 3576 matching lines @@
 
   gl_->ScheduleCALayerSharedStateCHROMIUM(
       ca_layer_overlay->shared_state->opacity, is_clipped, clip_rect,
       sorting_context_id, gl_transform);
   gl_->ScheduleCALayerCHROMIUM(
       texture_id, contents_rect, ca_layer_overlay->background_color,
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 }  // namespace cc