Update Context Client Visibility to use Scoped Pattern

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 66 matching lines @@
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/latency_info_swap_promise_monitor.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/GLES2/gl2extchromium.h"
-#include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 namespace {
 
@@ skipping 52 matching lines @@
   bool scroll_on_main_thread = (scroll_thread == MAIN_THREAD);
   if (IsWheelBasedScroll(type)) {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorWheelScrollUpdateThread",
                           scroll_on_main_thread);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorTouchScrollUpdateThread",
                           scroll_on_main_thread);
   }
 }
 
-// Calls SetClientVisible on the provided |context_provider| and handles
-// additional cache cleanup.
-void UpdateVisibilityForContextProvider(int client_id,
-                                        ContextProvider* context_provider,
-                                        bool is_visible) {
+void UpdateVisibilityForContextProvider(
+    ContextProvider* context_provider,
+    std::unique_ptr<gpu::ContextSupport::ScopedVisibility>* scoped_visibility,
+    bool is_visible) {
   if (!context_provider)
     return;
+  if (!!*scoped_visibility == is_visible)
+    return;
+
   gpu::ContextSupport* context_support = context_provider->ContextSupport();
 
-  context_support->SetClientVisible(client_id, is_visible);
-  bool aggressively_free_resources = !context_support->AnyClientsVisible();
-  if (aggressively_free_resources) {
+  if (is_visible)
+    *scoped_visibility = context_support->ClientBecameVisible();
+  else
+    context_support->ClientBecameNotVisible(std::move(*scoped_visibility));
+
+  if (!context_support->AnyClientsVisible())
     context_provider->DeleteCachedResources();
-  }
-  context_support->SetAggressivelyFreeResources(aggressively_free_resources);
 }
 
 // Same as UpdateVisibilityForContextProvider, except that the
 // |context_provider| is locked before being used.
 void LockAndUpdateVisibilityForContextProvider(
-    int client_id,
     ContextProvider* context_provider,
+    std::unique_ptr<gpu::ContextSupport::ScopedVisibility>* scoped_visibility,
     bool is_visible) {
   if (!context_provider)
     return;
+  if (!!*scoped_visibility == is_visible)
+    return;
+
   ContextProvider::ScopedContextLock hold(context_provider);
-  UpdateVisibilityForContextProvider(client_id, context_provider, is_visible);
+  UpdateVisibilityForContextProvider(context_provider, scoped_visibility,
+                                     is_visible);
 }
 
 }  // namespace
 
 DEFINE_SCOPED_UMA_HISTOGRAM_TIMER(PendingTreeDurationHistogramTimer,
                                   "Scheduling.%s.PendingTreeDuration");
 
 LayerTreeHostImpl::FrameData::FrameData()
     : render_surface_layer_list(nullptr),
       has_no_damage(false),
@@ skipping 1094 matching lines @@
                    : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
   global_tile_state_.num_resources_limit = policy.num_resources_limit;
 
   if (global_tile_state_.hard_memory_limit_in_bytes > 0) {
     // If |global_tile_state_.hard_memory_limit_in_bytes| is greater than 0, we
     // are visible. Notify the worker context here. We handle becoming
     // invisible in NotifyAllTileTasksComplete to avoid interrupting running
     // work.
     if (output_surface_) {
       LockAndUpdateVisibilityForContextProvider(
-          id_, output_surface_->worker_context_provider(),
-          true /* is_visible */);
+          output_surface_->worker_context_provider(),
+          &worker_context_client_visibility_, true /* is_visible */);
     }
 
     // If |global_tile_state_.hard_memory_limit_in_bytes| is greater than 0, we
     // allow the image decode controller to retain resources. We handle the
     // equal to 0 case in NotifyAllTileTasksComplete to avoid interrupting
     // running work.
     if (image_decode_controller_) {
       image_decode_controller_->SetShouldAggressivelyFreeResources(
           false /* aggressively_free_resources */);
     }
@@ skipping 72 matching lines @@
     // Free image decode controller resources before notifying the worker
     // context of visibility change. This ensures that the imaged decode
     // controller has released all Skia refs at the time Skia's cleanup
     // executes (within worker context's cleanup).
     if (image_decode_controller_) {
       image_decode_controller_->SetShouldAggressivelyFreeResources(
           true /* aggressively_free_resources */);
     }
     if (output_surface_) {
       LockAndUpdateVisibilityForContextProvider(
-          id_, output_surface_->worker_context_provider(),
-          false /* is_visible */);
+          output_surface_->worker_context_provider(),
+          &worker_context_client_visibility_, false /* is_visible */);
     }
   }
 }
 
 void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
 
   if (active_tree_) {
     LayerImpl* layer_impl =
         active_tree_->FindActiveTreeLayerById(tile->layer_id());
@@ skipping 719 matching lines @@
     // TODO(crbug.com/469175): Replace with RequiresHighResToDraw.
     SetRequiresHighResToDraw();
   } else {
     EvictAllUIResources();
     // Call PrepareTiles to evict tiles when we become invisible.
     PrepareTiles();
   }
 
   // Update visibility for the compositor context provider.
   if (output_surface_) {
-    UpdateVisibilityForContextProvider(id_, output_surface_->context_provider(),
+    UpdateVisibilityForContextProvider(output_surface_->context_provider(),
+                                       &main_context_client_visibility_,
                                        visible);
   }
 }
 
 void LayerTreeHostImpl::SetNeedsOneBeginImplFrame() {
   // TODO(miletus): This is just the compositor-thread-side call to the
   // SwapPromiseMonitor to say something happened that may cause a swap in the
   // future. The name should not refer to SetNeedsRedraw but it does for now.
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsOneBeginImplFrameOnImplThread();
@@ skipping 193 matching lines @@
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   ReleaseTreeResources();
 
   // Note: order is important here.
   renderer_ = nullptr;
   CleanUpTileManagerAndUIResources();
   resource_provider_ = nullptr;
 
-  // Detach from the old output surface and reset |output_surface_| pointer
-  // as this surface is going to be destroyed independent of if binding the
-  // new output surface succeeds or not.
   if (output_surface_) {
+    // Ensure that any context client visibility is left in a good state.
+    UpdateVisibilityForContextProvider(output_surface_->context_provider(),
+                                       &main_context_client_visibility_, false);
+    LockAndUpdateVisibilityForContextProvider(
+        output_surface_->worker_context_provider(),
+        &worker_context_client_visibility_, false);
+
+    // Detach from the old output surface and reset |output_surface_| pointer
+    // as this surface is going to be destroyed independent of if binding the
+    // new output surface succeeds or not.
     output_surface_->DetachFromClient();
     output_surface_ = nullptr;
   }
 
   // We don't know if the next OutputSurface will support GPU rasterization.
   // Make sure to clear the flag so that we force a re-computation.
   use_gpu_rasterization_ = false;
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(OutputSurface* output_surface) {
@@ skipping 1737 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc