Releasing Track & Thumb UIResources based on their Geometry

cc/layers/painted_scrollbar_layer.cc

 // Copyright 2013 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/layers/painted_scrollbar_layer.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
@@ skipping 112 matching lines @@
         track_rect_.x() - location_.x());
     scrollbar_layer->SetTrackLength(track_rect_.width());
   } else {
     scrollbar_layer->SetTrackStart(
         track_rect_.y() - location_.y());
     scrollbar_layer->SetTrackLength(track_rect_.height());
   }
 
   if (track_resource_.get())
     scrollbar_layer->set_track_ui_resource_id(track_resource_->id());
+  else
+    scrollbar_layer->set_track_ui_resource_id(0);
   if (thumb_resource_.get())
     scrollbar_layer->set_thumb_ui_resource_id(thumb_resource_->id());
+  else
+    scrollbar_layer->set_thumb_ui_resource_id(0);
 
   scrollbar_layer->set_is_overlay_scrollbar(is_overlay_);
 }
 
 ScrollbarLayerInterface* PaintedScrollbarLayer::ToScrollbarLayer() {
   return this;
 }
 
 void PaintedScrollbarLayer::PushScrollClipPropertiesTo(LayerImpl* layer) {
   PaintedScrollbarLayerImpl* scrollbar_layer =
@@ skipping 53 matching lines @@
   }
 }
 
 bool PaintedScrollbarLayer::Update(ResourceUpdateQueue* queue,
                                    const OcclusionTracker<Layer>* occlusion) {
   UpdateThumbAndTrackGeometry();
 
   gfx::Rect track_layer_rect = gfx::Rect(location_, bounds());
   gfx::Rect scaled_track_rect = ScrollbarLayerRectToContentRect(
       track_layer_rect);
+  bool updated = false;
+  if (track_rect_.IsEmpty() || scaled_track_rect.IsEmpty()) {
+    if (track_resource_) {
+      track_resource_.reset();
+      if (thumb_resource_)
+        thumb_resource_.reset();
+      SetNeedsPushProperties();
+      updated = true;
+    }
+    return updated;
+  }
 
-  if (track_rect_.IsEmpty() || scaled_track_rect.IsEmpty())
-    return false;
+  if (!has_thumb_ && thumb_resource_) {
+    thumb_resource_.reset();
+    SetNeedsPushProperties();

[danakj, 2014/09/15 18:16:27]

Thanks, can you add a test that will exercise this code branch and verify we
didn't early return? How about first have a track and a thumb, then resize the
track and SetNeedsDisplay(), and remove the thumb, and make sure the track
resource was resized? You could use LayerTreeHost::GetUIResourceSize to do this.

[MuVen, 2014/09/16 13:34:31]

Done.

+  }
 
   {
     base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
                                                   true);
     ContentsScalingLayer::Update(queue, occlusion);
   }
 
   if (update_rect_.IsEmpty() && track_resource_)
-    return false;
+    return updated;
 
   track_resource_ = ScopedUIResource::Create(
       layer_tree_host(),
       RasterizeScrollbarPart(track_layer_rect, scaled_track_rect, TRACK));
 
   gfx::Rect thumb_layer_rect = OriginThumbRect();
   gfx::Rect scaled_thumb_rect =
       ScrollbarLayerRectToContentRect(thumb_layer_rect);
   if (has_thumb_ && !scaled_thumb_rect.IsEmpty()) {
     thumb_resource_ = ScopedUIResource::Create(
         layer_tree_host(),
         RasterizeScrollbarPart(thumb_layer_rect, scaled_thumb_rect, THUMB));
   }
 
   // UI resources changed so push properties is needed.
   SetNeedsPushProperties();
-  return true;
+  updated = true;
+  return updated;
 }
 
 UIResourceBitmap PaintedScrollbarLayer::RasterizeScrollbarPart(
     const gfx::Rect& layer_rect,
     const gfx::Rect& content_rect,
     ScrollbarPart part) {
   DCHECK(!content_rect.size().IsEmpty());
   DCHECK(!layer_rect.size().IsEmpty());
 
   SkBitmap skbitmap;
@@ skipping 19 matching lines @@
 
   scrollbar_->PaintPart(&skcanvas, part, layer_rect);
   // Make sure that the pixels are no longer mutable to unavoid unnecessary
   // allocation and copying.
   skbitmap.setImmutable();
 
   return UIResourceBitmap(skbitmap);
 }
 
 }  // namespace cc