[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 1 | // Copyright 2012 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 | |
[email protected] | cc3cfaa | 2013-03-18 09:05:52 | [diff] [blame] | 5 | #include "cc/layers/picture_layer.h" |
[email protected] | f117a4c | 2012-12-16 04:53:10 | [diff] [blame] | 6 | |
[email protected] | 4ea293f7 | 2014-08-13 03:03:17 | [diff] [blame] | 7 | #include "base/auto_reset.h" |
[email protected] | f7837a9 | 2013-08-21 03:00:05 | [diff] [blame] | 8 | #include "cc/layers/content_layer_client.h" |
[email protected] | cc3cfaa | 2013-03-18 09:05:52 | [diff] [blame] | 9 | #include "cc/layers/picture_layer_impl.h" |
ajuma | 5e77f7d4 | 2014-11-27 14:19:14 | [diff] [blame] | 10 | #include "cc/resources/display_list_recording_source.h" |
hendrikw | 312ee8ac | 2014-11-12 23:24:34 | [diff] [blame] | 11 | #include "cc/resources/picture_pile.h" |
[email protected] | 556fd29 | 2013-03-18 08:03:04 | [diff] [blame] | 12 | #include "cc/trees/layer_tree_impl.h" |
[email protected] | de14c2c | 2014-04-24 01:02:25 | [diff] [blame] | 13 | #include "third_party/skia/include/core/SkPictureRecorder.h" |
heejin.r.chung | d28506ba | 2014-10-23 16:36:20 | [diff] [blame] | 14 | #include "ui/gfx/geometry/rect_conversions.h" |
[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 15 | |
| 16 | namespace cc { |
| 17 | |
[email protected] | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 18 | scoped_refptr<PictureLayer> PictureLayer::Create(ContentLayerClient* client) { |
[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 19 | return make_scoped_refptr(new PictureLayer(client)); |
| 20 | } |
| 21 | |
[email protected] | bf691c2 | 2013-03-26 21:15:06 | [diff] [blame] | 22 | PictureLayer::PictureLayer(ContentLayerClient* client) |
[email protected] | f6d55aa | 2014-03-11 20:42:53 | [diff] [blame] | 23 | : client_(client), |
[email protected] | f6d55aa | 2014-03-11 20:42:53 | [diff] [blame] | 24 | instrumentation_object_tracker_(id()), |
[email protected] | 36df063 | 2014-06-12 20:26:15 | [diff] [blame] | 25 | update_source_frame_number_(-1), |
danakj | 3f76ace | 2014-11-18 16:56:00 | [diff] [blame] | 26 | can_use_lcd_text_for_update_(true), |
jackhou | 2422961 | 2014-12-13 23:41:00 | [diff] [blame] | 27 | is_mask_(false), |
| 28 | nearest_neighbor_(false) { |
[email protected] | 36df063 | 2014-06-12 20:26:15 | [diff] [blame] | 29 | } |
[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 30 | |
danakj | a819c255 | 2014-11-14 02:05:04 | [diff] [blame] | 31 | PictureLayer::PictureLayer(ContentLayerClient* client, |
| 32 | scoped_ptr<RecordingSource> source) |
| 33 | : PictureLayer(client) { |
| 34 | recording_source_ = source.Pass(); |
| 35 | } |
| 36 | |
[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 37 | PictureLayer::~PictureLayer() { |
| 38 | } |
| 39 | |
[email protected] | 8c406cda3 | 2013-03-14 16:20:32 | [diff] [blame] | 40 | scoped_ptr<LayerImpl> PictureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) { |
danakj | a4ed6a2 | 2014-12-11 01:09:38 | [diff] [blame] | 41 | return PictureLayerImpl::Create(tree_impl, id(), is_mask_); |
[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 42 | } |
| 43 | |
[email protected] | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 44 | void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) { |
| 45 | Layer::PushPropertiesTo(base_layer); |
[email protected] | 3621e18 | 2012-11-09 22:37:09 | [diff] [blame] | 46 | PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer); |
danakj | a4ed6a2 | 2014-12-11 01:09:38 | [diff] [blame] | 47 | // TODO(danakj): Make is_mask_ a constructor parameter for PictureLayer. |
danakj | d193f6b | 2014-12-16 00:06:23 | [diff] [blame^] | 48 | DCHECK_EQ(layer_impl->is_mask(), is_mask_); |
[email protected] | 2325768 | 2013-05-17 22:53:03 | [diff] [blame] | 49 | |
danakj | 4537797 | 2014-11-06 22:05:49 | [diff] [blame] | 50 | int source_frame_number = layer_tree_host()->source_frame_number(); |
| 51 | gfx::Size impl_bounds = layer_impl->bounds(); |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 52 | gfx::Size recording_source_bounds = recording_source_->GetSize(); |
danakj | 4537797 | 2014-11-06 22:05:49 | [diff] [blame] | 53 | |
hendrikw | 312ee8ac | 2014-11-12 23:24:34 | [diff] [blame] | 54 | // If update called, then recording source size must match bounds pushed to |
| 55 | // impl layer. |
danakj | 4537797 | 2014-11-06 22:05:49 | [diff] [blame] | 56 | DCHECK_IMPLIES(update_source_frame_number_ == source_frame_number, |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 57 | impl_bounds == recording_source_bounds) |
hendrikw | 312ee8ac | 2014-11-12 23:24:34 | [diff] [blame] | 58 | << " bounds " << impl_bounds.ToString() << " recording source " |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 59 | << recording_source_bounds.ToString(); |
danakj | 4537797 | 2014-11-06 22:05:49 | [diff] [blame] | 60 | |
| 61 | if (update_source_frame_number_ != source_frame_number && |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 62 | recording_source_bounds != impl_bounds) { |
danakj | 4537797 | 2014-11-06 22:05:49 | [diff] [blame] | 63 | // Update may not get called for the layer (if it's not in the viewport |
hendrikw | 312ee8ac | 2014-11-12 23:24:34 | [diff] [blame] | 64 | // for example, even though it has resized making the recording source no |
| 65 | // longer valid. In this case just destroy the recording source. |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 66 | recording_source_->SetEmptyBounds(); |
[email protected] | eda36f0 | 2013-10-23 08:15:31 | [diff] [blame] | 67 | } |
| 68 | |
jackhou | 2422961 | 2014-12-13 23:41:00 | [diff] [blame] | 69 | layer_impl->SetNearestNeighbor(nearest_neighbor_); |
| 70 | |
hendrikw | 4e8c632 | 2014-11-18 05:46:32 | [diff] [blame] | 71 | scoped_refptr<RasterSource> raster_source = |
| 72 | recording_source_->CreateRasterSource(); |
| 73 | raster_source->SetBackgoundColor(SafeOpaqueBackgroundColor()); |
| 74 | raster_source->SetRequiresClear(!contents_opaque() && |
| 75 | !client_->FillsBoundsCompletely()); |
danakj | a4ed6a2 | 2014-12-11 01:09:38 | [diff] [blame] | 76 | layer_impl->UpdateRasterSource(raster_source, &recording_invalidation_, |
| 77 | nullptr); |
| 78 | DCHECK(recording_invalidation_.IsEmpty()); |
[email protected] | 3621e18 | 2012-11-09 22:37:09 | [diff] [blame] | 79 | } |
| 80 | |
[email protected] | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 81 | void PictureLayer::SetLayerTreeHost(LayerTreeHost* host) { |
| 82 | Layer::SetLayerTreeHost(host); |
[email protected] | f974be6 | 2013-02-28 19:12:26 | [diff] [blame] | 83 | if (host) { |
ajuma | 5e77f7d4 | 2014-11-27 14:19:14 | [diff] [blame] | 84 | if (!recording_source_) { |
| 85 | if (host->settings().use_display_lists) { |
| 86 | recording_source_.reset(new DisplayListRecordingSource); |
| 87 | } else { |
| 88 | recording_source_.reset(new PicturePile); |
| 89 | } |
| 90 | } |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 91 | recording_source_->SetMinContentsScale( |
| 92 | host->settings().minimum_contents_scale); |
| 93 | recording_source_->SetTileGridSize(host->settings().default_tile_grid_size); |
| 94 | recording_source_->SetSlowdownRasterScaleFactor( |
[email protected] | 846f455b | 2013-03-18 19:07:41 | [diff] [blame] | 95 | host->debug_state().slow_down_raster_scale_factor); |
[email protected] | f974be6 | 2013-02-28 19:12:26 | [diff] [blame] | 96 | } |
[email protected] | ce37a15 | 2013-01-08 17:12:33 | [diff] [blame] | 97 | } |
| 98 | |
danakj | 19f0c9e | 2014-10-11 03:24:42 | [diff] [blame] | 99 | void PictureLayer::SetNeedsDisplayRect(const gfx::Rect& layer_rect) { |
| 100 | if (!layer_rect.IsEmpty()) { |
[email protected] | 7a9fc13 | 2013-01-10 00:54:58 | [diff] [blame] | 101 | // Clamp invalidation to the layer bounds. |
danakj | 19f0c9e | 2014-10-11 03:24:42 | [diff] [blame] | 102 | pending_invalidation_.Union( |
| 103 | gfx::IntersectRects(layer_rect, gfx::Rect(bounds()))); |
[email protected] | 7a9fc13 | 2013-01-10 00:54:58 | [diff] [blame] | 104 | } |
[email protected] | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 105 | Layer::SetNeedsDisplayRect(layer_rect); |
[email protected] | 3621e18 | 2012-11-09 22:37:09 | [diff] [blame] | 106 | } |
| 107 | |
[email protected] | c50b99729 | 2013-08-03 18:44:30 | [diff] [blame] | 108 | bool PictureLayer::Update(ResourceUpdateQueue* queue, |
[email protected] | 34ba1ffb | 2014-03-05 06:55:03 | [diff] [blame] | 109 | const OcclusionTracker<Layer>* occlusion) { |
[email protected] | abe5134 | 2013-10-28 22:04:38 | [diff] [blame] | 110 | update_source_frame_number_ = layer_tree_host()->source_frame_number(); |
[email protected] | c50b99729 | 2013-08-03 18:44:30 | [diff] [blame] | 111 | bool updated = Layer::Update(queue, occlusion); |
| 112 | |
danakj | 3f76ace | 2014-11-18 16:56:00 | [diff] [blame] | 113 | bool can_use_lcd_text_changed = UpdateCanUseLCDText(); |
[email protected] | 36df063 | 2014-06-12 20:26:15 | [diff] [blame] | 114 | |
[email protected] | 4c159895 | 2014-04-16 02:54:48 | [diff] [blame] | 115 | gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect( |
| 116 | visible_content_rect(), 1.f / contents_scale_x()); |
[email protected] | a108f5db | 2014-07-16 06:10:27 | [diff] [blame] | 117 | gfx::Size layer_size = paint_properties().bounds; |
[email protected] | 4c159895 | 2014-04-16 02:54:48 | [diff] [blame] | 118 | |
[email protected] | 048ff15 | 2013-11-25 21:02:11 | [diff] [blame] | 119 | if (last_updated_visible_content_rect_ == visible_content_rect() && |
danakj | 3f76ace | 2014-11-18 16:56:00 | [diff] [blame] | 120 | recording_source_->GetSize() == layer_size && !can_use_lcd_text_changed && |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 121 | pending_invalidation_.IsEmpty()) { |
[email protected] | 048ff15 | 2013-11-25 21:02:11 | [diff] [blame] | 122 | // Only early out if the visible content rect of this layer hasn't changed. |
| 123 | return updated; |
| 124 | } |
| 125 | |
[email protected] | 08ac6f9e | 2013-12-04 05:44:09 | [diff] [blame] | 126 | TRACE_EVENT1("cc", "PictureLayer::Update", |
| 127 | "source_frame_number", |
| 128 | layer_tree_host()->source_frame_number()); |
[email protected] | 8af1ce1 | 2014-06-15 12:18:36 | [diff] [blame] | 129 | devtools_instrumentation::ScopedLayerTreeTask update_layer( |
| 130 | devtools_instrumentation::kUpdateLayer, id(), layer_tree_host()->id()); |
[email protected] | 08ac6f9e | 2013-12-04 05:44:09 | [diff] [blame] | 131 | |
[email protected] | 0e630ea3 | 2012-11-28 03:29:17 | [diff] [blame] | 132 | // Calling paint in WebKit can sometimes cause invalidations, so save |
| 133 | // off the invalidation prior to calling update. |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 134 | pending_invalidation_.Swap(&recording_invalidation_); |
[email protected] | 0e630ea3 | 2012-11-28 03:29:17 | [diff] [blame] | 135 | pending_invalidation_.Clear(); |
| 136 | |
[email protected] | 8a59280 | 2014-07-02 07:31:33 | [diff] [blame] | 137 | if (layer_tree_host()->settings().record_full_layer) { |
[email protected] | c1079b53 | 2013-07-18 01:22:31 | [diff] [blame] | 138 | // Workaround for http://crbug.com/235910 - to retain backwards compat |
| 139 | // the full page content must always be provided in the picture layer. |
[email protected] | a108f5db | 2014-07-16 06:10:27 | [diff] [blame] | 140 | visible_layer_rect = gfx::Rect(layer_size); |
[email protected] | c1079b53 | 2013-07-18 01:22:31 | [diff] [blame] | 141 | } |
[email protected] | 8f322ba | 2014-06-18 23:48:18 | [diff] [blame] | 142 | |
| 143 | // UpdateAndExpandInvalidation will give us an invalidation that covers |
| 144 | // anything not explicitly recorded in this frame. We give this region |
| 145 | // to the impl side so that it drops tiles that may not have a recording |
| 146 | // for them. |
[email protected] | 1d96e03 | 2014-03-25 05:59:08 | [diff] [blame] | 147 | DCHECK(client_); |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 148 | updated |= recording_source_->UpdateAndExpandInvalidation( |
danakj | 3f76ace | 2014-11-18 16:56:00 | [diff] [blame] | 149 | client_, &recording_invalidation_, can_use_lcd_text_for_update_, |
| 150 | layer_size, visible_layer_rect, update_source_frame_number_, |
| 151 | Picture::RECORD_NORMALLY); |
[email protected] | 048ff15 | 2013-11-25 21:02:11 | [diff] [blame] | 152 | last_updated_visible_content_rect_ = visible_content_rect(); |
| 153 | |
[email protected] | 214c8697 | 2013-08-20 23:43:06 | [diff] [blame] | 154 | if (updated) { |
| 155 | SetNeedsPushProperties(); |
| 156 | } else { |
hendrikw | 312ee8ac | 2014-11-12 23:24:34 | [diff] [blame] | 157 | // If this invalidation did not affect the recording source, then it can be |
| 158 | // cleared as an optimization. |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 159 | recording_invalidation_.Clear(); |
[email protected] | 49304bde | 2013-07-08 21:31:22 | [diff] [blame] | 160 | } |
[email protected] | 214c8697 | 2013-08-20 23:43:06 | [diff] [blame] | 161 | |
[email protected] | 49304bde | 2013-07-08 21:31:22 | [diff] [blame] | 162 | return updated; |
[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 163 | } |
| 164 | |
[email protected] | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 165 | void PictureLayer::SetIsMask(bool is_mask) { |
hendrikw | 4e8c632 | 2014-11-18 05:46:32 | [diff] [blame] | 166 | is_mask_ = is_mask; |
[email protected] | f677653 | 2012-12-21 20:24:33 | [diff] [blame] | 167 | } |
| 168 | |
[email protected] | 7924c185 | 2013-05-24 16:18:43 | [diff] [blame] | 169 | bool PictureLayer::SupportsLCDText() const { |
| 170 | return true; |
| 171 | } |
| 172 | |
danakj | 3f76ace | 2014-11-18 16:56:00 | [diff] [blame] | 173 | bool PictureLayer::UpdateCanUseLCDText() { |
| 174 | if (!can_use_lcd_text_for_update_) |
| 175 | return false; // Don't allow the LCD text state to change once disabled. |
| 176 | if (can_use_lcd_text_for_update_ == can_use_lcd_text()) |
| 177 | return false; |
[email protected] | 36df063 | 2014-06-12 20:26:15 | [diff] [blame] | 178 | |
danakj | 3f76ace | 2014-11-18 16:56:00 | [diff] [blame] | 179 | can_use_lcd_text_for_update_ = can_use_lcd_text(); |
| 180 | return true; |
[email protected] | 36df063 | 2014-06-12 20:26:15 | [diff] [blame] | 181 | } |
| 182 | |
[email protected] | f7837a9 | 2013-08-21 03:00:05 | [diff] [blame] | 183 | skia::RefPtr<SkPicture> PictureLayer::GetPicture() const { |
hendrikw | 312ee8ac | 2014-11-12 23:24:34 | [diff] [blame] | 184 | // We could either flatten the RecordingSource into a single SkPicture, |
[email protected] | f7837a9 | 2013-08-21 03:00:05 | [diff] [blame] | 185 | // or paint a fresh one depending on what we intend to do with the |
| 186 | // picture. For now we just paint a fresh one to get consistent results. |
| 187 | if (!DrawsContent()) |
| 188 | return skia::RefPtr<SkPicture>(); |
| 189 | |
| 190 | int width = bounds().width(); |
| 191 | int height = bounds().height(); |
[email protected] | f7837a9 | 2013-08-21 03:00:05 | [diff] [blame] | 192 | |
[email protected] | e93fbdd | 2014-04-16 17:34:21 | [diff] [blame] | 193 | SkPictureRecorder recorder; |
kulkarni.a | 4015690f1 | 2014-10-10 13:50:06 | [diff] [blame] | 194 | SkCanvas* canvas = recorder.beginRecording(width, height, nullptr, 0); |
[email protected] | 276172b | 2014-05-02 21:03:03 | [diff] [blame] | 195 | client_->PaintContents(canvas, |
| 196 | gfx::Rect(width, height), |
[email protected] | 276172b | 2014-05-02 21:03:03 | [diff] [blame] | 197 | ContentLayerClient::GRAPHICS_CONTEXT_ENABLED); |
[email protected] | e93fbdd | 2014-04-16 17:34:21 | [diff] [blame] | 198 | skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording()); |
[email protected] | f7837a9 | 2013-08-21 03:00:05 | [diff] [blame] | 199 | return picture; |
| 200 | } |
| 201 | |
[email protected] | a6c1b23 | 2014-05-05 23:53:08 | [diff] [blame] | 202 | bool PictureLayer::IsSuitableForGpuRasterization() const { |
hendrikw | 9d909aa7 | 2014-11-11 20:19:52 | [diff] [blame] | 203 | return recording_source_->IsSuitableForGpuRasterization(); |
[email protected] | a6c1b23 | 2014-05-05 23:53:08 | [diff] [blame] | 204 | } |
| 205 | |
[email protected] | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 206 | void PictureLayer::ClearClient() { |
kulkarni.a | 4015690f1 | 2014-10-10 13:50:06 | [diff] [blame] | 207 | client_ = nullptr; |
[email protected] | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 208 | UpdateDrawsContent(HasDrawableContent()); |
| 209 | } |
| 210 | |
jackhou | 2422961 | 2014-12-13 23:41:00 | [diff] [blame] | 211 | void PictureLayer::SetNearestNeighbor(bool nearest_neighbor) { |
| 212 | if (nearest_neighbor_ == nearest_neighbor) |
| 213 | return; |
| 214 | |
| 215 | nearest_neighbor_ = nearest_neighbor; |
| 216 | SetNeedsCommit(); |
| 217 | } |
| 218 | |
[email protected] | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 219 | bool PictureLayer::HasDrawableContent() const { |
| 220 | return client_ && Layer::HasDrawableContent(); |
| 221 | } |
| 222 | |
[email protected] | 1a55d7dc | 2013-10-12 07:52:20 | [diff] [blame] | 223 | void PictureLayer::RunMicroBenchmark(MicroBenchmark* benchmark) { |
| 224 | benchmark->RunOnLayer(this); |
| 225 | } |
| 226 | |
[email protected] | d98c024 | 2012-11-08 06:22:35 | [diff] [blame] | 227 | } // namespace cc |