cc: Clear checker-image tracking on navigation and visibility changes.

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 1262 matching lines @@
     // becoming invisible in NotifyAllTileTasksComplete to avoid interrupting
     // running work.
     SetContextVisibility(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_cache_)
       image_decode_cache_->SetShouldAggressivelyFreeResources(false);
+  } else {
+    // Clear checkered image state so we unlock cached images. Since we will be
+    // evicting all tile resources and images from the ImageDecodeCache, this
+    // also ensures that we re-checker these images.
+    tile_manager_.ClearCheckerImageTracking();

[vmpstr, 2017/05/09 22:06:21]

Can you verify what happens in a resourceless software draw for a webview? I
think we might set the memory limit to 0 there as well or is that not true?

[Khushal, 2017/05/10 00:53:17]

Do you think this is okay for the general case? In particular I'm considering
how this will interact with partial raster. If we are able to acquire any
resources on becoming visible, we might trigger re-raster only for some tiles,
on which images will be checkered. And when that decode finishes, it will cause
an invalidation for all tiles with that image on the next pending tree.

   }
 
   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 1039 matching lines @@
 }
 
 std::vector<base::Closure>
 LayerTreeHostImpl::TakeCompletedImageDecodeCallbacks() {
   auto result = std::move(completed_image_decode_callbacks_);
   completed_image_decode_callbacks_.clear();
   return result;
 }
 
 void LayerTreeHostImpl::ClearImageCacheOnNavigation() {
+  tile_manager_.ClearCheckerImageTracking();
   if (image_decode_cache_)
     image_decode_cache_->ClearCache();
 }
 
 void LayerTreeHostImpl::DidChangeScrollbarVisibility() {
   // Need a commit since input handling for scrollbars is handled in Blink so
   // we need to communicate to Blink when the compositor shows/hides the
   // scrollbars.
   client_->SetNeedsCommitOnImplThread();
 }
@@ skipping 1939 matching lines @@
 
 void LayerTreeHostImpl::ShowScrollbarsForImplScroll(ElementId element_id) {
   if (!element_id)
     return;
   if (ScrollbarAnimationController* animation_controller =
           ScrollbarAnimationControllerForElementId(element_id))
     animation_controller->DidScrollUpdate();
 }
 
 }  // namespace cc