| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/layers/painted_scrollbar_layer.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/auto_reset.h" | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/trace_event/trace_event.h" | |
| 12 #include "cc/base/math_util.h" | |
| 13 #include "cc/layers/painted_scrollbar_layer_impl.h" | |
| 14 #include "cc/resources/ui_resource_bitmap.h" | |
| 15 #include "cc/trees/layer_tree_host.h" | |
| 16 #include "cc/trees/layer_tree_impl.h" | |
| 17 #include "skia/ext/platform_canvas.h" | |
| 18 #include "skia/ext/refptr.h" | |
| 19 #include "third_party/skia/include/core/SkBitmap.h" | |
| 20 #include "third_party/skia/include/core/SkCanvas.h" | |
| 21 #include "third_party/skia/include/core/SkSize.h" | |
| 22 #include "ui/gfx/geometry/size_conversions.h" | |
| 23 #include "ui/gfx/skia_util.h" | |
| 24 | |
| 25 namespace cc { | |
| 26 | |
| 27 scoped_ptr<LayerImpl> PaintedScrollbarLayer::CreateLayerImpl( | |
| 28 LayerTreeImpl* tree_impl) { | |
| 29 return PaintedScrollbarLayerImpl::Create( | |
| 30 tree_impl, id(), scrollbar_->Orientation()); | |
| 31 } | |
| 32 | |
| 33 scoped_refptr<PaintedScrollbarLayer> PaintedScrollbarLayer::Create( | |
| 34 scoped_ptr<Scrollbar> scrollbar, | |
| 35 int scroll_layer_id) { | |
| 36 return make_scoped_refptr( | |
| 37 new PaintedScrollbarLayer(scrollbar.Pass(), scroll_layer_id)); | |
| 38 } | |
| 39 | |
| 40 PaintedScrollbarLayer::PaintedScrollbarLayer(scoped_ptr<Scrollbar> scrollbar, | |
| 41 int scroll_layer_id) | |
| 42 : scrollbar_(scrollbar.Pass()), | |
| 43 scroll_layer_id_(scroll_layer_id), | |
| 44 clip_layer_id_(Layer::INVALID_ID), | |
| 45 internal_contents_scale_(0.f), | |
| 46 thumb_thickness_(scrollbar_->ThumbThickness()), | |
| 47 thumb_length_(scrollbar_->ThumbLength()), | |
| 48 is_overlay_(scrollbar_->IsOverlay()), | |
| 49 has_thumb_(scrollbar_->HasThumb()) { | |
| 50 if (!scrollbar_->IsOverlay()) | |
| 51 SetShouldScrollOnMainThread(true); | |
| 52 } | |
| 53 | |
| 54 PaintedScrollbarLayer::~PaintedScrollbarLayer() {} | |
| 55 | |
| 56 int PaintedScrollbarLayer::ScrollLayerId() const { | |
| 57 return scroll_layer_id_; | |
| 58 } | |
| 59 | |
| 60 void PaintedScrollbarLayer::SetScrollLayer(int layer_id) { | |
| 61 if (layer_id == scroll_layer_id_) | |
| 62 return; | |
| 63 | |
| 64 scroll_layer_id_ = layer_id; | |
| 65 SetNeedsFullTreeSync(); | |
| 66 } | |
| 67 | |
| 68 void PaintedScrollbarLayer::SetClipLayer(int layer_id) { | |
| 69 if (layer_id == clip_layer_id_) | |
| 70 return; | |
| 71 | |
| 72 clip_layer_id_ = layer_id; | |
| 73 SetNeedsFullTreeSync(); | |
| 74 } | |
| 75 | |
| 76 bool PaintedScrollbarLayer::OpacityCanAnimateOnImplThread() const { | |
| 77 return scrollbar_->IsOverlay(); | |
| 78 } | |
| 79 | |
| 80 ScrollbarOrientation PaintedScrollbarLayer::orientation() const { | |
| 81 return scrollbar_->Orientation(); | |
| 82 } | |
| 83 | |
| 84 int PaintedScrollbarLayer::MaxTextureSize() { | |
| 85 DCHECK(layer_tree_host()); | |
| 86 return layer_tree_host()->GetRendererCapabilities().max_texture_size; | |
| 87 } | |
| 88 | |
| 89 float PaintedScrollbarLayer::ClampScaleToMaxTextureSize(float scale) { | |
| 90 // If the scaled bounds() is bigger than the max texture size of the | |
| 91 // device, we need to clamp it by rescaling, since this is used | |
| 92 // below to set the texture size. | |
| 93 gfx::Size scaled_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(), scale)); | |
| 94 if (scaled_bounds.width() > MaxTextureSize() || | |
| 95 scaled_bounds.height() > MaxTextureSize()) { | |
| 96 if (scaled_bounds.width() > scaled_bounds.height()) | |
| 97 return (MaxTextureSize() - 1) / static_cast<float>(bounds().width()); | |
| 98 else | |
| 99 return (MaxTextureSize() - 1) / static_cast<float>(bounds().height()); | |
| 100 } | |
| 101 return scale; | |
| 102 } | |
| 103 | |
| 104 void PaintedScrollbarLayer::PushPropertiesTo(LayerImpl* layer) { | |
| 105 Layer::PushPropertiesTo(layer); | |
| 106 | |
| 107 PushScrollClipPropertiesTo(layer); | |
| 108 | |
| 109 PaintedScrollbarLayerImpl* scrollbar_layer = | |
| 110 static_cast<PaintedScrollbarLayerImpl*>(layer); | |
| 111 | |
| 112 scrollbar_layer->set_internal_contents_scale_and_bounds( | |
| 113 internal_contents_scale_, internal_content_bounds_); | |
| 114 | |
| 115 scrollbar_layer->SetThumbThickness(thumb_thickness_); | |
| 116 scrollbar_layer->SetThumbLength(thumb_length_); | |
| 117 if (orientation() == HORIZONTAL) { | |
| 118 scrollbar_layer->SetTrackStart( | |
| 119 track_rect_.x() - location_.x()); | |
| 120 scrollbar_layer->SetTrackLength(track_rect_.width()); | |
| 121 } else { | |
| 122 scrollbar_layer->SetTrackStart( | |
| 123 track_rect_.y() - location_.y()); | |
| 124 scrollbar_layer->SetTrackLength(track_rect_.height()); | |
| 125 } | |
| 126 | |
| 127 if (track_resource_.get()) | |
| 128 scrollbar_layer->set_track_ui_resource_id(track_resource_->id()); | |
| 129 else | |
| 130 scrollbar_layer->set_track_ui_resource_id(0); | |
| 131 if (thumb_resource_.get()) | |
| 132 scrollbar_layer->set_thumb_ui_resource_id(thumb_resource_->id()); | |
| 133 else | |
| 134 scrollbar_layer->set_thumb_ui_resource_id(0); | |
| 135 | |
| 136 scrollbar_layer->set_is_overlay_scrollbar(is_overlay_); | |
| 137 } | |
| 138 | |
| 139 ScrollbarLayerInterface* PaintedScrollbarLayer::ToScrollbarLayer() { | |
| 140 return this; | |
| 141 } | |
| 142 | |
| 143 void PaintedScrollbarLayer::PushScrollClipPropertiesTo(LayerImpl* layer) { | |
| 144 PaintedScrollbarLayerImpl* scrollbar_layer = | |
| 145 static_cast<PaintedScrollbarLayerImpl*>(layer); | |
| 146 | |
| 147 scrollbar_layer->SetScrollLayerAndClipLayerByIds(scroll_layer_id_, | |
| 148 clip_layer_id_); | |
| 149 } | |
| 150 | |
| 151 void PaintedScrollbarLayer::SetLayerTreeHost(LayerTreeHost* host) { | |
| 152 // When the LTH is set to null or has changed, then this layer should remove | |
| 153 // all of its associated resources. | |
| 154 if (!host || host != layer_tree_host()) { | |
| 155 track_resource_ = nullptr; | |
| 156 thumb_resource_ = nullptr; | |
| 157 } | |
| 158 | |
| 159 Layer::SetLayerTreeHost(host); | |
| 160 } | |
| 161 | |
| 162 gfx::Rect PaintedScrollbarLayer::ScrollbarLayerRectToContentRect( | |
| 163 const gfx::Rect& layer_rect) const { | |
| 164 // Don't intersect with the bounds as in LayerRectToContentRect() because | |
| 165 // layer_rect here might be in coordinates of the containing layer. | |
| 166 gfx::Rect expanded_rect = gfx::ScaleToEnclosingRect( | |
| 167 layer_rect, internal_contents_scale_, internal_contents_scale_); | |
| 168 // We should never return a rect bigger than the content bounds. | |
| 169 gfx::Size clamped_size = expanded_rect.size(); | |
| 170 clamped_size.SetToMin(internal_content_bounds_); | |
| 171 expanded_rect.set_size(clamped_size); | |
| 172 return expanded_rect; | |
| 173 } | |
| 174 | |
| 175 gfx::Rect PaintedScrollbarLayer::OriginThumbRect() const { | |
| 176 gfx::Size thumb_size; | |
| 177 if (orientation() == HORIZONTAL) { | |
| 178 thumb_size = | |
| 179 gfx::Size(scrollbar_->ThumbLength(), scrollbar_->ThumbThickness()); | |
| 180 } else { | |
| 181 thumb_size = | |
| 182 gfx::Size(scrollbar_->ThumbThickness(), scrollbar_->ThumbLength()); | |
| 183 } | |
| 184 return gfx::Rect(thumb_size); | |
| 185 } | |
| 186 | |
| 187 void PaintedScrollbarLayer::UpdateThumbAndTrackGeometry() { | |
| 188 UpdateProperty(scrollbar_->TrackRect(), &track_rect_); | |
| 189 UpdateProperty(scrollbar_->Location(), &location_); | |
| 190 UpdateProperty(scrollbar_->IsOverlay(), &is_overlay_); | |
| 191 UpdateProperty(scrollbar_->HasThumb(), &has_thumb_); | |
| 192 if (has_thumb_) { | |
| 193 UpdateProperty(scrollbar_->ThumbThickness(), &thumb_thickness_); | |
| 194 UpdateProperty(scrollbar_->ThumbLength(), &thumb_length_); | |
| 195 } else { | |
| 196 UpdateProperty(0, &thumb_thickness_); | |
| 197 UpdateProperty(0, &thumb_length_); | |
| 198 } | |
| 199 } | |
| 200 | |
| 201 void PaintedScrollbarLayer::UpdateInternalContentScale() { | |
| 202 float scale = layer_tree_host()->device_scale_factor(); | |
| 203 if (layer_tree_host() | |
| 204 ->settings() | |
| 205 .layer_transforms_should_scale_layer_contents) { | |
| 206 gfx::Vector2dF transform_scales = | |
| 207 MathUtil::ComputeTransform2dScaleComponents(draw_transform(), scale); | |
| 208 scale = std::max(transform_scales.x(), transform_scales.y()); | |
| 209 } | |
| 210 bool changed = false; | |
| 211 changed |= UpdateProperty(ClampScaleToMaxTextureSize(scale), | |
| 212 &internal_contents_scale_); | |
| 213 changed |= UpdateProperty( | |
| 214 gfx::ToCeiledSize(gfx::ScaleSize(bounds(), internal_contents_scale_)), | |
| 215 &internal_content_bounds_); | |
| 216 if (changed) { | |
| 217 // If the content scale or bounds change, repaint. | |
| 218 SetNeedsDisplay(); | |
| 219 } | |
| 220 } | |
| 221 | |
| 222 bool PaintedScrollbarLayer::Update(ResourceUpdateQueue* queue, | |
| 223 const OcclusionTracker<Layer>* occlusion) { | |
| 224 { | |
| 225 base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_, | |
| 226 true); | |
| 227 Layer::Update(queue, occlusion); | |
| 228 UpdateInternalContentScale(); | |
| 229 } | |
| 230 | |
| 231 UpdateThumbAndTrackGeometry(); | |
| 232 | |
| 233 gfx::Rect track_layer_rect = gfx::Rect(location_, bounds()); | |
| 234 gfx::Rect scaled_track_rect = ScrollbarLayerRectToContentRect( | |
| 235 track_layer_rect); | |
| 236 | |
| 237 bool updated = false; | |
| 238 | |
| 239 if (track_rect_.IsEmpty() || scaled_track_rect.IsEmpty()) { | |
| 240 if (track_resource_) { | |
| 241 track_resource_ = nullptr; | |
| 242 thumb_resource_ = nullptr; | |
| 243 SetNeedsPushProperties(); | |
| 244 updated = true; | |
| 245 } | |
| 246 return updated; | |
| 247 } | |
| 248 | |
| 249 if (!has_thumb_ && thumb_resource_) { | |
| 250 thumb_resource_ = nullptr; | |
| 251 SetNeedsPushProperties(); | |
| 252 updated = true; | |
| 253 } | |
| 254 | |
| 255 if (update_rect_.IsEmpty() && track_resource_) | |
| 256 return updated; | |
| 257 | |
| 258 track_resource_ = ScopedUIResource::Create( | |
| 259 layer_tree_host(), | |
| 260 RasterizeScrollbarPart(track_layer_rect, scaled_track_rect, TRACK)); | |
| 261 | |
| 262 gfx::Rect thumb_layer_rect = OriginThumbRect(); | |
| 263 gfx::Rect scaled_thumb_rect = | |
| 264 ScrollbarLayerRectToContentRect(thumb_layer_rect); | |
| 265 if (has_thumb_ && !scaled_thumb_rect.IsEmpty()) { | |
| 266 thumb_resource_ = ScopedUIResource::Create( | |
| 267 layer_tree_host(), | |
| 268 RasterizeScrollbarPart(thumb_layer_rect, scaled_thumb_rect, THUMB)); | |
| 269 } | |
| 270 | |
| 271 // UI resources changed so push properties is needed. | |
| 272 SetNeedsPushProperties(); | |
| 273 updated = true; | |
| 274 return updated; | |
| 275 } | |
| 276 | |
| 277 UIResourceBitmap PaintedScrollbarLayer::RasterizeScrollbarPart( | |
| 278 const gfx::Rect& layer_rect, | |
| 279 const gfx::Rect& content_rect, | |
| 280 ScrollbarPart part) { | |
| 281 DCHECK(!content_rect.size().IsEmpty()); | |
| 282 DCHECK(!layer_rect.size().IsEmpty()); | |
| 283 | |
| 284 SkBitmap skbitmap; | |
| 285 skbitmap.allocN32Pixels(content_rect.width(), content_rect.height()); | |
| 286 SkCanvas skcanvas(skbitmap); | |
| 287 | |
| 288 float scale_x = | |
| 289 content_rect.width() / static_cast<float>(layer_rect.width()); | |
| 290 float scale_y = | |
| 291 content_rect.height() / static_cast<float>(layer_rect.height()); | |
| 292 | |
| 293 skcanvas.scale(SkFloatToScalar(scale_x), | |
| 294 SkFloatToScalar(scale_y)); | |
| 295 skcanvas.translate(SkFloatToScalar(-layer_rect.x()), | |
| 296 SkFloatToScalar(-layer_rect.y())); | |
| 297 | |
| 298 SkRect layer_skrect = RectToSkRect(layer_rect); | |
| 299 SkPaint paint; | |
| 300 paint.setAntiAlias(false); | |
| 301 paint.setXfermodeMode(SkXfermode::kClear_Mode); | |
| 302 skcanvas.drawRect(layer_skrect, paint); | |
| 303 skcanvas.clipRect(layer_skrect); | |
| 304 | |
| 305 scrollbar_->PaintPart(&skcanvas, part, layer_rect); | |
| 306 // Make sure that the pixels are no longer mutable to unavoid unnecessary | |
| 307 // allocation and copying. | |
| 308 skbitmap.setImmutable(); | |
| 309 | |
| 310 return UIResourceBitmap(skbitmap); | |
| 311 } | |
| 312 | |
| 313 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master