cc: Make PaintedScrollbarLayer not use ContentsScalingLayer

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 <algorithm>
+
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/base/math_util.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSize.h"
+#include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 
 scoped_ptr<LayerImpl> PaintedScrollbarLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return PaintedScrollbarLayerImpl::Create(
       tree_impl, id(), scrollbar_->Orientation());
 }
 
 scoped_refptr<PaintedScrollbarLayer> PaintedScrollbarLayer::Create(
     scoped_ptr<Scrollbar> scrollbar,
     int scroll_layer_id) {
   return make_scoped_refptr(
       new PaintedScrollbarLayer(scrollbar.Pass(), scroll_layer_id));
 }
 
 PaintedScrollbarLayer::PaintedScrollbarLayer(scoped_ptr<Scrollbar> scrollbar,
                                              int scroll_layer_id)
     : scrollbar_(scrollbar.Pass()),
       scroll_layer_id_(scroll_layer_id),
       clip_layer_id_(Layer::INVALID_ID),
+      internal_content_scale_(0.f),
       thumb_thickness_(scrollbar_->ThumbThickness()),
       thumb_length_(scrollbar_->ThumbLength()),
       is_overlay_(scrollbar_->IsOverlay()),
       has_thumb_(scrollbar_->HasThumb()) {
   if (!scrollbar_->IsOverlay())
     SetShouldScrollOnMainThread(true);
 }
 
 PaintedScrollbarLayer::~PaintedScrollbarLayer() {}
 
@@ skipping 24 matching lines @@
 ScrollbarOrientation PaintedScrollbarLayer::orientation() const {
   return scrollbar_->Orientation();
 }
 
 int PaintedScrollbarLayer::MaxTextureSize() {
   DCHECK(layer_tree_host());
   return layer_tree_host()->GetRendererCapabilities().max_texture_size;
 }
 
 float PaintedScrollbarLayer::ClampScaleToMaxTextureSize(float scale) {
-  // If the scaled content_bounds() is bigger than the max texture size of the
-  // device, we need to clamp it by rescaling, since content_bounds() is used
+  // If the scaled bounds() is bigger than the max texture size of the
+  // device, we need to clamp it by rescaling, since this is used
   // below to set the texture size.
-  gfx::Size scaled_bounds = ComputeContentBoundsForScale(scale, scale);
+  gfx::Size scaled_bounds =
+      gfx::ToCeiledSize(gfx::ScaleSize(bounds(), scale, scale));
   if (scaled_bounds.width() > MaxTextureSize() ||
       scaled_bounds.height() > MaxTextureSize()) {
     if (scaled_bounds.width() > scaled_bounds.height())
       return (MaxTextureSize() - 1) / static_cast<float>(bounds().width());
     else
       return (MaxTextureSize() - 1) / static_cast<float>(bounds().height());
   }
   return scale;
 }
 
-void PaintedScrollbarLayer::CalculateContentsScale(
-    float ideal_contents_scale,
-    float* contents_scale_x,
-    float* contents_scale_y,
-    gfx::Size* content_bounds) {
-  ContentsScalingLayer::CalculateContentsScale(
-      ClampScaleToMaxTextureSize(ideal_contents_scale),
-      contents_scale_x,
-      contents_scale_y,
-      content_bounds);
-}
-
 void PaintedScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
-  ContentsScalingLayer::PushPropertiesTo(layer);
+  Layer::PushPropertiesTo(layer);
 
   PushScrollClipPropertiesTo(layer);
 
   PaintedScrollbarLayerImpl* scrollbar_layer =
       static_cast<PaintedScrollbarLayerImpl*>(layer);
 
+  scrollbar_layer->set_internal_content_scale_and_bounds(
+      internal_content_scale_, internal_content_bounds_);
+
   scrollbar_layer->SetThumbThickness(thumb_thickness_);
   scrollbar_layer->SetThumbLength(thumb_length_);
   if (orientation() == HORIZONTAL) {
     scrollbar_layer->SetTrackStart(
         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());
@@ skipping 24 matching lines @@
 }
 
 void PaintedScrollbarLayer::SetLayerTreeHost(LayerTreeHost* host) {
   // When the LTH is set to null or has changed, then this layer should remove
   // all of its associated resources.
   if (!host || host != layer_tree_host()) {
     track_resource_ = nullptr;
     thumb_resource_ = nullptr;
   }
 
-  ContentsScalingLayer::SetLayerTreeHost(host);
+  Layer::SetLayerTreeHost(host);
 }
 
 gfx::Rect PaintedScrollbarLayer::ScrollbarLayerRectToContentRect(
     const gfx::Rect& layer_rect) const {
   // Don't intersect with the bounds as in LayerRectToContentRect() because
   // layer_rect here might be in coordinates of the containing layer.
   gfx::Rect expanded_rect = gfx::ScaleToEnclosingRect(
-      layer_rect, contents_scale_x(), contents_scale_y());
-  // We should never return a rect bigger than the content_bounds().
+      layer_rect, internal_content_scale_, internal_content_scale_);
+  // We should never return a rect bigger than the content bounds.
   gfx::Size clamped_size = expanded_rect.size();
-  clamped_size.SetToMin(content_bounds());
+  clamped_size.SetToMin(internal_content_bounds_);
   expanded_rect.set_size(clamped_size);
   return expanded_rect;
 }
 
 gfx::Rect PaintedScrollbarLayer::OriginThumbRect() const {
   gfx::Size thumb_size;
   if (orientation() == HORIZONTAL) {
     thumb_size =
         gfx::Size(scrollbar_->ThumbLength(), scrollbar_->ThumbThickness());
   } else {
@@ skipping 10 matching lines @@
   UpdateProperty(scrollbar_->HasThumb(), &has_thumb_);
   if (has_thumb_) {
     UpdateProperty(scrollbar_->ThumbThickness(), &thumb_thickness_);
     UpdateProperty(scrollbar_->ThumbLength(), &thumb_length_);
   } else {
     UpdateProperty(0, &thumb_thickness_);
     UpdateProperty(0, &thumb_length_);
   }
 }
 
+void PaintedScrollbarLayer::UpdateInternalContentScale() {
+  float scale = layer_tree_host()->device_scale_factor();

[enne (OOO), 2015/02/11 21:41:59]

This is a change in behavior from ContentsScalingLayer, which defaults to using
device scale factor + page scale factor when the layer has a transform that
scales can't be extracted from.  I don't worry very hard about pixelated
scrollbars on transformed layers during page zoom, but I thought I'd mention
that it's a subtle change in behavior.

+  if (layer_tree_host()
+          ->settings()
+          .layer_transforms_should_scale_layer_contents) {
+    gfx::Vector2dF transform_scales =
+        MathUtil::ComputeTransform2dScaleComponents(draw_transform(), scale);
+    scale = std::max(transform_scales.x(), transform_scales.y());
+  }
+  bool changed = false;
+  changed |= UpdateProperty(ClampScaleToMaxTextureSize(scale),
+                            &internal_content_scale_);
+  changed |= UpdateProperty(
+      gfx::ToCeiledSize(gfx::ScaleSize(bounds(), internal_content_scale_)),
+      &internal_content_bounds_);
+  if (changed) {
+    // If the content scale or bounds change, repaint.
+    SetNeedsDisplay();

[enne (OOO), 2015/02/11 21:41:58]

This replicates ContentsScalingLayer::Update, although it also SetNeedsDisplay
when the bounds changed, which unit tests needed, and seems more correct.

+  }
+}
+
 bool PaintedScrollbarLayer::Update(ResourceUpdateQueue* queue,
                                    const OcclusionTracker<Layer>* occlusion) {
+  {
+    base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
+                                                  true);
+    Layer::Update(queue, occlusion);
+    UpdateInternalContentScale();

[enne (OOO), 2015/02/11 21:41:59]

As UpdateInternalContentScale can invalidate, it needs to be in this auto reset
block to avoid an extra commit.

+  }
+
   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_ = nullptr;
       thumb_resource_ = nullptr;
       SetNeedsPushProperties();
       updated = true;
     }
     return updated;
   }
 
   if (!has_thumb_ && thumb_resource_) {
     thumb_resource_ = nullptr;
     SetNeedsPushProperties();
-  }
-
-  {
-    base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
-                                                  true);
-    ContentsScalingLayer::Update(queue, occlusion);
+    updated = true;

[enne (OOO), 2015/02/11 21:41:59]

I don't know why this didn't set updated, but it seemed like an oversight.

   }
 
   if (update_rect_.IsEmpty() && track_resource_)
     return updated;
 
   track_resource_ = ScopedUIResource::Create(
       layer_tree_host(),
       RasterizeScrollbarPart(track_layer_rect, scaled_track_rect, TRACK));
 
   gfx::Rect thumb_layer_rect = OriginThumbRect();
@@ skipping 41 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