Refactor client visibility handling

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 139 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) {
-  if (!context_provider)
-    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) {
-    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,
-    bool is_visible) {
-  if (!context_provider)
-    return;
-  ContextProvider::ScopedContextLock hold(context_provider);
-  UpdateVisibilityForContextProvider(client_id, context_provider, is_visible);
-}
-
 }  // namespace
 
 DEFINE_SCOPED_UMA_HISTOGRAM_TIMER(PendingTreeDurationHistogramTimer,
                                   "Scheduling.%s.PendingTreeDuration");
 
 LayerTreeHostImpl::FrameData::FrameData()
     : render_surface_layer_list(nullptr),
       has_no_damage(false),
       may_contain_video(false) {}
 
@@ skipping 1090 matching lines @@
       ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
           visible_ ? policy.priority_cutoff_when_visible
                    : 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 */);
-    }
+    SetWorkerContextVisibility(true);
 
     // 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 */);
-    }
+    if (image_decode_controller_)
+      image_decode_controller_->SetShouldAggressivelyFreeResources(false);
   }
 
   DCHECK(resource_pool_);
   resource_pool_->CheckBusyResources();
   // Soft limit is used for resource pool such that memory returns to soft
   // limit after going over.
   resource_pool_->SetResourceUsageLimits(
       global_tile_state_.soft_memory_limit_in_bytes,
       global_tile_state_.num_resources_limit);
 
@@ skipping 56 matching lines @@
 }
 
 void LayerTreeHostImpl::NotifyAllTileTasksCompleted() {
   // The tile tasks started by the most recent call to PrepareTiles have
   // completed. Now is a good time to free resources if necessary.
   if (global_tile_state_.hard_memory_limit_in_bytes == 0) {
     // 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 */);
-    }
+    if (image_decode_controller_)
+      image_decode_controller_->SetShouldAggressivelyFreeResources(true);
+    SetWorkerContextVisibility(false);
   }
 }
 
 void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
 
   if (active_tree_) {
     LayerImpl* layer_impl =
         active_tree_->FindActiveTreeLayerById(tile->layer_id());
     if (layer_impl)
@@ skipping 711 matching lines @@
   if (visible_) {
     // 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(),
-                                       visible);
-  }
+  SetCompositorContextVisibility(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;
 
+  // Release any context visibility before we destroy the OutputSurface.
+  if (visible_)
+    SetCompositorContextVisibility(false);
+  // Worker context visibility is based on both LTHI visibility as well as
+  // memory policy, so we directly check |worker_context_visibility_| here,
+  // rather than just relying on |visibility_|.
+  if (worker_context_visibility_)
+    SetWorkerContextVisibility(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.
   if (output_surface_) {
     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.
@@ skipping 15 matching lines @@
   resource_provider_ = base::MakeUnique<ResourceProvider>(
       output_surface_->context_provider(), shared_bitmap_manager_,
       gpu_memory_buffer_manager_,
       task_runner_provider_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
       output_surface_->capabilities().delegated_sync_points_required,
       settings_.renderer_settings.use_gpu_memory_buffer_resources,
       settings_.renderer_settings.buffer_to_texture_target_map);
 
+  // Make sure the main context visibility is restored. Worker context
+  // visibility will be set via the memory policy update in
+  // CreateTileManagerResources below.
+  if (visible_)
+    SetCompositorContextVisibility(true);
+
   // Since the new context may be capable of MSAA, update status here. We don't
   // need to check the return value since we are recreating all resources
   // already.
   UpdateGpuRasterizationStatus();
 
   CreateAndSetRenderer();
 
   CreateTileManagerResources();
   RecreateTreeResources();
 
@@ skipping 1790 matching lines @@
   // Supported in threaded mode.
   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();
 }
 
+void LayerTreeHostImpl::SetCompositorContextVisibility(bool is_visible) {
+  if (!output_surface_)
+    return;
+
+  auto* compositor_context = output_surface_->context_provider();
+  if (!compositor_context)
+    return;
+
+  DCHECK_NE(is_visible, !!compositor_context_visibility_);
+
+  if (is_visible) {
+    compositor_context_visibility_ =
+        compositor_context->CacheController()->ClientBecameVisible();
+  } else {
+    compositor_context->CacheController()->ClientBecameNotVisible(
+        std::move(compositor_context_visibility_));
+  }
+}
+
+void LayerTreeHostImpl::SetWorkerContextVisibility(bool is_visible) {
+  if (!output_surface_)
+    return;
+
+  auto* worker_context = output_surface_->worker_context_provider();
+  if (!worker_context)
+    return;
+
+  // TODO(ericrk): This check is here because worker context visibility is a
+  // bit less controlled, being settable both by memory policy changes as well
+  // as direct visibility changes. We should simplify this. crbug.com/642154
+  if (is_visible == !!worker_context_visibility_)
+    return;
+
+  ContextProvider::ScopedContextLock hold(worker_context);
+  if (is_visible) {
+    worker_context_visibility_ =
+        worker_context->CacheController()->ClientBecameVisible();
+  } else {
+    worker_context->CacheController()->ClientBecameNotVisible(
+        std::move(worker_context_visibility_));
+  }
+}
+
 }  // namespace cc