OLD | NEW |
---|---|
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/resources/tile_manager.h" | 5 #include "cc/resources/tile_manager.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 #include <string> | 9 #include <string> |
10 | 10 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
52 content_rect_(content_rect), | 52 content_rect_(content_rect), |
53 contents_scale_(contents_scale), | 53 contents_scale_(contents_scale), |
54 raster_mode_(raster_mode), | 54 raster_mode_(raster_mode), |
55 tile_resolution_(tile_resolution), | 55 tile_resolution_(tile_resolution), |
56 layer_id_(layer_id), | 56 layer_id_(layer_id), |
57 tile_id_(tile_id), | 57 tile_id_(tile_id), |
58 source_frame_number_(source_frame_number), | 58 source_frame_number_(source_frame_number), |
59 analyze_picture_(analyze_picture), | 59 analyze_picture_(analyze_picture), |
60 rendering_stats_(rendering_stats), | 60 rendering_stats_(rendering_stats), |
61 reply_(reply), | 61 reply_(reply), |
62 canvas_(NULL) {} | 62 raster_buffer_(NULL) {} |
63 | 63 |
64 // Overridden from Task: | 64 // Overridden from Task: |
65 virtual void RunOnWorkerThread() OVERRIDE { | 65 virtual void RunOnWorkerThread() OVERRIDE { |
66 TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread"); | 66 TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread"); |
67 | 67 |
68 DCHECK(picture_pile_.get()); | 68 DCHECK(picture_pile_.get()); |
69 if (!canvas_) | 69 DCHECK(raster_buffer_); |
70 return; | |
71 | 70 |
72 if (analyze_picture_) { | 71 if (analyze_picture_) { |
73 Analyze(picture_pile_.get()); | 72 Analyze(picture_pile_.get()); |
74 if (analysis_.is_solid_color) | 73 if (analysis_.is_solid_color) |
75 return; | 74 return; |
76 } | 75 } |
77 | 76 |
78 Raster(picture_pile_.get()); | 77 Raster(picture_pile_.get()); |
79 } | 78 } |
80 | 79 |
81 // Overridden from RasterizerTask: | 80 // Overridden from RasterizerTask: |
82 virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE { | 81 virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE { |
83 DCHECK(!canvas_); | 82 DCHECK(!raster_buffer_); |
84 canvas_ = client->AcquireCanvasForRaster(this); | 83 raster_buffer_ = client->AcquireBufferForRaster(this); |
85 } | 84 } |
86 virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE { | 85 virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE { |
87 canvas_ = NULL; | 86 raster_buffer_ = NULL; |
88 client->ReleaseCanvasForRaster(this); | 87 client->ReleaseBufferForRaster(this); |
89 } | 88 } |
90 virtual void RunReplyOnOriginThread() OVERRIDE { | 89 virtual void RunReplyOnOriginThread() OVERRIDE { |
91 DCHECK(!canvas_); | 90 DCHECK(!raster_buffer_); |
92 reply_.Run(analysis_, !HasFinishedRunning()); | 91 reply_.Run(analysis_, !HasFinishedRunning()); |
93 } | 92 } |
94 | 93 |
95 protected: | 94 protected: |
96 virtual ~RasterTaskImpl() { DCHECK(!canvas_); } | 95 virtual ~RasterTaskImpl() { DCHECK(!raster_buffer_); } |
97 | 96 |
98 private: | 97 private: |
99 void Analyze(const PicturePileImpl* picture_pile) { | 98 void Analyze(const PicturePileImpl* picture_pile) { |
100 frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task( | 99 frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task( |
101 tile_id_, tile_resolution_, source_frame_number_, layer_id_); | 100 tile_id_, tile_resolution_, source_frame_number_, layer_id_); |
102 | 101 |
103 DCHECK(picture_pile); | 102 DCHECK(picture_pile); |
104 | 103 |
105 picture_pile->AnalyzeInRect( | 104 picture_pile->AnalyzeInRect( |
106 content_rect_, contents_scale_, &analysis_, rendering_stats_); | 105 content_rect_, contents_scale_, &analysis_, rendering_stats_); |
107 | 106 |
108 // Record the solid color prediction. | 107 // Record the solid color prediction. |
109 UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed", | 108 UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed", |
110 analysis_.is_solid_color); | 109 analysis_.is_solid_color); |
111 | 110 |
112 // Clear the flag if we're not using the estimator. | 111 // Clear the flag if we're not using the estimator. |
113 analysis_.is_solid_color &= kUseColorEstimator; | 112 analysis_.is_solid_color &= kUseColorEstimator; |
114 } | 113 } |
115 | 114 |
116 void Raster(const PicturePileImpl* picture_pile) { | 115 void Raster(const PicturePileImpl* picture_pile) { |
117 frame_viewer_instrumentation::ScopedRasterTask raster_task( | 116 frame_viewer_instrumentation::ScopedRasterTask raster_task( |
118 tile_id_, | 117 tile_id_, |
119 tile_resolution_, | 118 tile_resolution_, |
120 source_frame_number_, | 119 source_frame_number_, |
121 layer_id_, | 120 layer_id_, |
122 raster_mode_); | 121 raster_mode_); |
123 devtools_instrumentation::ScopedLayerTask layer_task( | 122 devtools_instrumentation::ScopedLayerTask layer_task( |
124 devtools_instrumentation::kRasterTask, layer_id_); | 123 devtools_instrumentation::kRasterTask, layer_id_); |
125 | 124 |
125 skia::RefPtr<SkCanvas> canvas = raster_buffer_->AcquireSkCanvas(); | |
126 if (!canvas) | |
127 return; | |
128 canvas->save(); | |
reveman
2014/09/10 21:12:22
Sorry, I think I missed this while reviewing. Why
auygun
2014/09/11 08:27:07
All tiles were black when using GPU raster buffer.
reveman
2014/09/11 16:47:13
OK, thanks! FYI, I might move this into the raster
| |
129 | |
126 skia::RefPtr<SkDrawFilter> draw_filter; | 130 skia::RefPtr<SkDrawFilter> draw_filter; |
127 switch (raster_mode_) { | 131 switch (raster_mode_) { |
128 case LOW_QUALITY_RASTER_MODE: | 132 case LOW_QUALITY_RASTER_MODE: |
129 draw_filter = skia::AdoptRef(new skia::PaintSimplifier); | 133 draw_filter = skia::AdoptRef(new skia::PaintSimplifier); |
130 break; | 134 break; |
131 case HIGH_QUALITY_RASTER_MODE: | 135 case HIGH_QUALITY_RASTER_MODE: |
132 break; | 136 break; |
133 case NUM_RASTER_MODES: | 137 case NUM_RASTER_MODES: |
134 default: | 138 default: |
135 NOTREACHED(); | 139 NOTREACHED(); |
136 } | 140 } |
137 canvas_->setDrawFilter(draw_filter.get()); | 141 canvas->setDrawFilter(draw_filter.get()); |
138 | 142 |
139 base::TimeDelta prev_rasterize_time = | 143 base::TimeDelta prev_rasterize_time = |
140 rendering_stats_->impl_thread_rendering_stats().rasterize_time; | 144 rendering_stats_->impl_thread_rendering_stats().rasterize_time; |
141 | 145 |
142 // Only record rasterization time for highres tiles, because | 146 // Only record rasterization time for highres tiles, because |
143 // lowres tiles are not required for activation and therefore | 147 // lowres tiles are not required for activation and therefore |
144 // introduce noise in the measurement (sometimes they get rasterized | 148 // introduce noise in the measurement (sometimes they get rasterized |
145 // before we draw and sometimes they aren't) | 149 // before we draw and sometimes they aren't) |
146 RenderingStatsInstrumentation* stats = | 150 RenderingStatsInstrumentation* stats = |
147 tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL; | 151 tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL; |
148 DCHECK(picture_pile); | 152 DCHECK(picture_pile); |
149 picture_pile->RasterToBitmap( | 153 picture_pile->RasterToBitmap( |
150 canvas_, content_rect_, contents_scale_, stats); | 154 canvas.get(), content_rect_, contents_scale_, stats); |
151 | 155 |
152 if (rendering_stats_->record_rendering_stats()) { | 156 if (rendering_stats_->record_rendering_stats()) { |
153 base::TimeDelta current_rasterize_time = | 157 base::TimeDelta current_rasterize_time = |
154 rendering_stats_->impl_thread_rendering_stats().rasterize_time; | 158 rendering_stats_->impl_thread_rendering_stats().rasterize_time; |
155 LOCAL_HISTOGRAM_CUSTOM_COUNTS( | 159 LOCAL_HISTOGRAM_CUSTOM_COUNTS( |
156 "Renderer4.PictureRasterTimeUS", | 160 "Renderer4.PictureRasterTimeUS", |
157 (current_rasterize_time - prev_rasterize_time).InMicroseconds(), | 161 (current_rasterize_time - prev_rasterize_time).InMicroseconds(), |
158 0, | 162 0, |
159 100000, | 163 100000, |
160 100); | 164 100); |
161 } | 165 } |
166 | |
167 canvas->restore(); | |
168 raster_buffer_->ReleaseSkCanvas(canvas); | |
162 } | 169 } |
163 | 170 |
164 PicturePileImpl::Analysis analysis_; | 171 PicturePileImpl::Analysis analysis_; |
165 scoped_refptr<PicturePileImpl> picture_pile_; | 172 scoped_refptr<PicturePileImpl> picture_pile_; |
166 gfx::Rect content_rect_; | 173 gfx::Rect content_rect_; |
167 float contents_scale_; | 174 float contents_scale_; |
168 RasterMode raster_mode_; | 175 RasterMode raster_mode_; |
169 TileResolution tile_resolution_; | 176 TileResolution tile_resolution_; |
170 int layer_id_; | 177 int layer_id_; |
171 const void* tile_id_; | 178 const void* tile_id_; |
172 int source_frame_number_; | 179 int source_frame_number_; |
173 bool analyze_picture_; | 180 bool analyze_picture_; |
174 RenderingStatsInstrumentation* rendering_stats_; | 181 RenderingStatsInstrumentation* rendering_stats_; |
175 const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_; | 182 const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_; |
176 SkCanvas* canvas_; | 183 RasterBuffer* raster_buffer_; |
177 | 184 |
178 DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl); | 185 DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl); |
179 }; | 186 }; |
180 | 187 |
181 class ImageDecodeTaskImpl : public ImageDecodeTask { | 188 class ImageDecodeTaskImpl : public ImageDecodeTask { |
182 public: | 189 public: |
183 ImageDecodeTaskImpl(SkPixelRef* pixel_ref, | 190 ImageDecodeTaskImpl(SkPixelRef* pixel_ref, |
184 int layer_id, | 191 int layer_id, |
185 RenderingStatsInstrumentation* rendering_stats, | 192 RenderingStatsInstrumentation* rendering_stats, |
186 const base::Callback<void(bool was_canceled)>& reply) | 193 const base::Callback<void(bool was_canceled)>& reply) |
(...skipping 982 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1169 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); | 1176 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); |
1170 | 1177 |
1171 rasterizer_->CheckForCompletedTasks(); | 1178 rasterizer_->CheckForCompletedTasks(); |
1172 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 1179 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
1173 | 1180 |
1174 if (IsReadyToActivate()) | 1181 if (IsReadyToActivate()) |
1175 client_->NotifyReadyToActivate(); | 1182 client_->NotifyReadyToActivate(); |
1176 } | 1183 } |
1177 | 1184 |
1178 } // namespace cc | 1185 } // namespace cc |
OLD | NEW |