| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/resources/image_copy_raster_worker_pool.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/debug/trace_event.h" | |
| 10 #include "base/debug/trace_event_argument.h" | |
| 11 #include "base/strings/stringprintf.h" | |
| 12 #include "cc/debug/traced_value.h" | |
| 13 #include "cc/resources/raster_buffer.h" | |
| 14 #include "cc/resources/resource_pool.h" | |
| 15 #include "cc/resources/scoped_resource.h" | |
| 16 #include "gpu/command_buffer/client/gles2_interface.h" | |
| 17 #include "third_party/skia/include/utils/SkNullCanvas.h" | |
| 18 | |
| 19 namespace cc { | |
| 20 namespace { | |
| 21 | |
| 22 class RasterBufferImpl : public RasterBuffer { | |
| 23 public: | |
| 24 RasterBufferImpl(ResourceProvider* resource_provider, | |
| 25 ResourcePool* resource_pool, | |
| 26 const Resource* resource) | |
| 27 : resource_provider_(resource_provider), | |
| 28 resource_pool_(resource_pool), | |
| 29 resource_(resource), | |
| 30 raster_resource_(resource_pool->AcquireResource(resource->size())), | |
| 31 buffer_(NULL), | |
| 32 stride_(0) { | |
| 33 // Acquire and map image for raster resource. | |
| 34 resource_provider_->AcquireImage(raster_resource_->id()); | |
| 35 buffer_ = resource_provider_->MapImage(raster_resource_->id(), &stride_); | |
| 36 } | |
| 37 | |
| 38 virtual ~RasterBufferImpl() { | |
| 39 // First unmap image for raster resource. | |
| 40 resource_provider_->UnmapImage(raster_resource_->id()); | |
| 41 | |
| 42 // Copy contents of raster resource to |resource_|. | |
| 43 resource_provider_->CopyResource(raster_resource_->id(), resource_->id()); | |
| 44 | |
| 45 // This RasterBuffer implementation provides direct access to the memory | |
| 46 // used by the GPU. Read lock fences are required to ensure that we're not | |
| 47 // trying to map a resource that is currently in-use by the GPU. | |
| 48 resource_provider_->EnableReadLockFences(raster_resource_->id()); | |
| 49 | |
| 50 // Return raster resource to pool so it can be used by another RasterBuffer | |
| 51 // instance. | |
| 52 resource_pool_->ReleaseResource(raster_resource_.Pass()); | |
| 53 } | |
| 54 | |
| 55 // Overridden from RasterBuffer: | |
| 56 virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE { | |
| 57 if (!buffer_) | |
| 58 return skia::AdoptRef(SkCreateNullCanvas()); | |
| 59 | |
| 60 RasterWorkerPool::AcquireBitmapForBuffer( | |
| 61 &bitmap_, buffer_, resource_->format(), resource_->size(), stride_); | |
| 62 return skia::AdoptRef(new SkCanvas(bitmap_)); | |
| 63 } | |
| 64 virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE { | |
| 65 if (!buffer_) | |
| 66 return; | |
| 67 | |
| 68 RasterWorkerPool::ReleaseBitmapForBuffer( | |
| 69 &bitmap_, buffer_, resource_->format()); | |
| 70 } | |
| 71 | |
| 72 private: | |
| 73 ResourceProvider* resource_provider_; | |
| 74 ResourcePool* resource_pool_; | |
| 75 const Resource* resource_; | |
| 76 scoped_ptr<ScopedResource> raster_resource_; | |
| 77 uint8_t* buffer_; | |
| 78 int stride_; | |
| 79 SkBitmap bitmap_; | |
| 80 | |
| 81 DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl); | |
| 82 }; | |
| 83 | |
| 84 } // namespace | |
| 85 | |
| 86 // static | |
| 87 scoped_ptr<RasterWorkerPool> ImageCopyRasterWorkerPool::Create( | |
| 88 base::SequencedTaskRunner* task_runner, | |
| 89 TaskGraphRunner* task_graph_runner, | |
| 90 ContextProvider* context_provider, | |
| 91 ResourceProvider* resource_provider, | |
| 92 ResourcePool* resource_pool) { | |
| 93 return make_scoped_ptr<RasterWorkerPool>( | |
| 94 new ImageCopyRasterWorkerPool(task_runner, | |
| 95 task_graph_runner, | |
| 96 context_provider, | |
| 97 resource_provider, | |
| 98 resource_pool)); | |
| 99 } | |
| 100 | |
| 101 ImageCopyRasterWorkerPool::ImageCopyRasterWorkerPool( | |
| 102 base::SequencedTaskRunner* task_runner, | |
| 103 TaskGraphRunner* task_graph_runner, | |
| 104 ContextProvider* context_provider, | |
| 105 ResourceProvider* resource_provider, | |
| 106 ResourcePool* resource_pool) | |
| 107 : task_runner_(task_runner), | |
| 108 task_graph_runner_(task_graph_runner), | |
| 109 namespace_token_(task_graph_runner->GetNamespaceToken()), | |
| 110 context_provider_(context_provider), | |
| 111 resource_provider_(resource_provider), | |
| 112 resource_pool_(resource_pool), | |
| 113 raster_finished_weak_ptr_factory_(this) { | |
| 114 DCHECK(context_provider_); | |
| 115 } | |
| 116 | |
| 117 ImageCopyRasterWorkerPool::~ImageCopyRasterWorkerPool() { | |
| 118 } | |
| 119 | |
| 120 Rasterizer* ImageCopyRasterWorkerPool::AsRasterizer() { return this; } | |
| 121 | |
| 122 void ImageCopyRasterWorkerPool::SetClient(RasterizerClient* client) { | |
| 123 client_ = client; | |
| 124 } | |
| 125 | |
| 126 void ImageCopyRasterWorkerPool::Shutdown() { | |
| 127 TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::Shutdown"); | |
| 128 | |
| 129 TaskGraph empty; | |
| 130 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); | |
| 131 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); | |
| 132 } | |
| 133 | |
| 134 void ImageCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { | |
| 135 TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::ScheduleTasks"); | |
| 136 | |
| 137 if (raster_pending_.none()) | |
| 138 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); | |
| 139 | |
| 140 // Mark all task sets as pending. | |
| 141 raster_pending_.set(); | |
| 142 | |
| 143 unsigned priority = kRasterTaskPriorityBase; | |
| 144 | |
| 145 graph_.Reset(); | |
| 146 | |
| 147 // Cancel existing OnRasterFinished callbacks. | |
| 148 raster_finished_weak_ptr_factory_.InvalidateWeakPtrs(); | |
| 149 | |
| 150 scoped_refptr<RasterizerTask> new_raster_finished_tasks[kNumberOfTaskSets]; | |
| 151 | |
| 152 size_t task_count[kNumberOfTaskSets] = {0}; | |
| 153 | |
| 154 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | |
| 155 new_raster_finished_tasks[task_set] = CreateRasterFinishedTask( | |
| 156 task_runner_.get(), | |
| 157 base::Bind(&ImageCopyRasterWorkerPool::OnRasterFinished, | |
| 158 raster_finished_weak_ptr_factory_.GetWeakPtr(), | |
| 159 task_set)); | |
| 160 } | |
| 161 | |
| 162 resource_pool_->CheckBusyResources(); | |
| 163 | |
| 164 for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); | |
| 165 it != queue->items.end(); | |
| 166 ++it) { | |
| 167 const RasterTaskQueue::Item& item = *it; | |
| 168 RasterTask* task = item.task; | |
| 169 DCHECK(!task->HasCompleted()); | |
| 170 | |
| 171 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | |
| 172 if (!item.task_sets[task_set]) | |
| 173 continue; | |
| 174 | |
| 175 ++task_count[task_set]; | |
| 176 | |
| 177 graph_.edges.push_back( | |
| 178 TaskGraph::Edge(task, new_raster_finished_tasks[task_set].get())); | |
| 179 } | |
| 180 | |
| 181 InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++); | |
| 182 } | |
| 183 | |
| 184 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | |
| 185 InsertNodeForTask(&graph_, | |
| 186 new_raster_finished_tasks[task_set].get(), | |
| 187 kRasterFinishedTaskPriority, | |
| 188 task_count[task_set]); | |
| 189 } | |
| 190 | |
| 191 ScheduleTasksOnOriginThread(this, &graph_); | |
| 192 task_graph_runner_->ScheduleTasks(namespace_token_, &graph_); | |
| 193 | |
| 194 std::copy(new_raster_finished_tasks, | |
| 195 new_raster_finished_tasks + kNumberOfTaskSets, | |
| 196 raster_finished_tasks_); | |
| 197 | |
| 198 resource_pool_->ReduceResourceUsage(); | |
| 199 | |
| 200 TRACE_EVENT_ASYNC_STEP_INTO1( | |
| 201 "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue()); | |
| 202 } | |
| 203 | |
| 204 void ImageCopyRasterWorkerPool::CheckForCompletedTasks() { | |
| 205 TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::CheckForCompletedTasks"); | |
| 206 | |
| 207 task_graph_runner_->CollectCompletedTasks(namespace_token_, | |
| 208 &completed_tasks_); | |
| 209 for (Task::Vector::const_iterator it = completed_tasks_.begin(); | |
| 210 it != completed_tasks_.end(); | |
| 211 ++it) { | |
| 212 RasterizerTask* task = static_cast<RasterizerTask*>(it->get()); | |
| 213 | |
| 214 task->WillComplete(); | |
| 215 task->CompleteOnOriginThread(this); | |
| 216 task->DidComplete(); | |
| 217 | |
| 218 task->RunReplyOnOriginThread(); | |
| 219 } | |
| 220 completed_tasks_.clear(); | |
| 221 | |
| 222 context_provider_->ContextGL()->ShallowFlushCHROMIUM(); | |
| 223 } | |
| 224 | |
| 225 scoped_ptr<RasterBuffer> ImageCopyRasterWorkerPool::AcquireBufferForRaster( | |
| 226 const Resource* resource) { | |
| 227 DCHECK_EQ(resource->format(), resource_pool_->resource_format()); | |
| 228 return make_scoped_ptr<RasterBuffer>( | |
| 229 new RasterBufferImpl(resource_provider_, resource_pool_, resource)); | |
| 230 } | |
| 231 | |
| 232 void ImageCopyRasterWorkerPool::ReleaseBufferForRaster( | |
| 233 scoped_ptr<RasterBuffer> buffer) { | |
| 234 // Nothing to do here. RasterBufferImpl destructor cleans up after itself. | |
| 235 } | |
| 236 | |
| 237 void ImageCopyRasterWorkerPool::OnRasterFinished(TaskSet task_set) { | |
| 238 TRACE_EVENT1("cc", | |
| 239 "ImageCopyRasterWorkerPool::OnRasterFinished", | |
| 240 "task_set", | |
| 241 task_set); | |
| 242 | |
| 243 DCHECK(raster_pending_[task_set]); | |
| 244 raster_pending_[task_set] = false; | |
| 245 if (raster_pending_.any()) { | |
| 246 TRACE_EVENT_ASYNC_STEP_INTO1( | |
| 247 "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue()); | |
| 248 } else { | |
| 249 TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this); | |
| 250 } | |
| 251 client_->DidFinishRunningTasks(task_set); | |
| 252 } | |
| 253 | |
| 254 scoped_refptr<base::debug::ConvertableToTraceFormat> | |
| 255 ImageCopyRasterWorkerPool::StateAsValue() const { | |
| 256 scoped_refptr<base::debug::TracedValue> state = | |
| 257 new base::debug::TracedValue(); | |
| 258 | |
| 259 state->BeginArray("tasks_pending"); | |
| 260 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) | |
| 261 state->AppendBoolean(raster_pending_[task_set]); | |
| 262 state->EndArray(); | |
| 263 state->BeginDictionary("staging_state"); | |
| 264 StagingStateAsValueInto(state.get()); | |
| 265 state->EndDictionary(); | |
| 266 | |
| 267 return state; | |
| 268 } | |
| 269 void ImageCopyRasterWorkerPool::StagingStateAsValueInto( | |
| 270 base::debug::TracedValue* staging_state) const { | |
| 271 staging_state->SetInteger("staging_resource_count", | |
| 272 resource_pool_->total_resource_count()); | |
| 273 staging_state->SetInteger("bytes_used_for_staging_resources", | |
| 274 resource_pool_->total_memory_usage_bytes()); | |
| 275 staging_state->SetInteger("pending_copy_count", | |
| 276 resource_pool_->total_resource_count() - | |
| 277 resource_pool_->acquired_resource_count()); | |
| 278 staging_state->SetInteger("bytes_pending_copy", | |
| 279 resource_pool_->total_memory_usage_bytes() - | |
| 280 resource_pool_->acquired_memory_usage_bytes()); | |
| 281 } | |
| 282 | |
| 283 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 584393003:
cc: Use more explicit names for CHROMIUM_image based rasterizer implementations. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master