OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 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/raster/zero_copy_tile_task_worker_pool.h" | 5 #include "cc/raster/zero_copy_raster_buffer_provider.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 | 10 |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
12 #include "base/memory/ptr_util.h" | 12 #include "base/memory/ptr_util.h" |
13 #include "base/strings/stringprintf.h" | 13 #include "base/strings/stringprintf.h" |
14 #include "base/trace_event/trace_event.h" | 14 #include "base/trace_event/trace_event.h" |
15 #include "base/trace_event/trace_event_argument.h" | 15 #include "base/trace_event/trace_event_argument.h" |
(...skipping 21 matching lines...) Expand all Loading... |
37 float scale, | 37 float scale, |
38 const RasterSource::PlaybackSettings& playback_settings) override { | 38 const RasterSource::PlaybackSettings& playback_settings) override { |
39 gfx::GpuMemoryBuffer* buffer = lock_.GetGpuMemoryBuffer(); | 39 gfx::GpuMemoryBuffer* buffer = lock_.GetGpuMemoryBuffer(); |
40 if (!buffer) | 40 if (!buffer) |
41 return; | 41 return; |
42 | 42 |
43 DCHECK_EQ(1u, gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat())); | 43 DCHECK_EQ(1u, gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat())); |
44 bool rv = buffer->Map(); | 44 bool rv = buffer->Map(); |
45 DCHECK(rv); | 45 DCHECK(rv); |
46 DCHECK(buffer->memory(0)); | 46 DCHECK(buffer->memory(0)); |
47 // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides. | 47 // RasterBufferProvider::PlaybackToMemory only supports unsigned strides. |
48 DCHECK_GE(buffer->stride(0), 0); | 48 DCHECK_GE(buffer->stride(0), 0); |
49 | 49 |
50 // TODO(danakj): Implement partial raster with raster_dirty_rect. | 50 // TODO(danakj): Implement partial raster with raster_dirty_rect. |
51 TileTaskWorkerPool::PlaybackToMemory( | 51 RasterBufferProvider::PlaybackToMemory( |
52 buffer->memory(0), resource_->format(), resource_->size(), | 52 buffer->memory(0), resource_->format(), resource_->size(), |
53 buffer->stride(0), raster_source, raster_full_rect, raster_full_rect, | 53 buffer->stride(0), raster_source, raster_full_rect, raster_full_rect, |
54 scale, playback_settings); | 54 scale, playback_settings); |
55 buffer->Unmap(); | 55 buffer->Unmap(); |
56 } | 56 } |
57 | 57 |
58 private: | 58 private: |
59 ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock_; | 59 ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock_; |
60 const Resource* resource_; | 60 const Resource* resource_; |
61 | 61 |
62 DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl); | 62 DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl); |
63 }; | 63 }; |
64 | 64 |
65 } // namespace | 65 } // namespace |
66 | 66 |
67 // static | 67 // static |
68 std::unique_ptr<TileTaskWorkerPool> ZeroCopyTileTaskWorkerPool::Create( | 68 std::unique_ptr<RasterBufferProvider> ZeroCopyRasterBufferProvider::Create( |
69 base::SequencedTaskRunner* task_runner, | |
70 TaskGraphRunner* task_graph_runner, | |
71 ResourceProvider* resource_provider, | 69 ResourceProvider* resource_provider, |
72 ResourceFormat preferred_tile_format) { | 70 ResourceFormat preferred_tile_format) { |
73 return base::WrapUnique<TileTaskWorkerPool>( | 71 return base::WrapUnique<RasterBufferProvider>( |
74 new ZeroCopyTileTaskWorkerPool(task_runner, task_graph_runner, | 72 new ZeroCopyRasterBufferProvider(resource_provider, |
75 resource_provider, preferred_tile_format)); | 73 preferred_tile_format)); |
76 } | 74 } |
77 | 75 |
78 ZeroCopyTileTaskWorkerPool::ZeroCopyTileTaskWorkerPool( | 76 ZeroCopyRasterBufferProvider::ZeroCopyRasterBufferProvider( |
79 base::SequencedTaskRunner* task_runner, | |
80 TaskGraphRunner* task_graph_runner, | |
81 ResourceProvider* resource_provider, | 77 ResourceProvider* resource_provider, |
82 ResourceFormat preferred_tile_format) | 78 ResourceFormat preferred_tile_format) |
83 : task_runner_(task_runner), | 79 : resource_provider_(resource_provider), |
84 task_graph_runner_(task_graph_runner), | |
85 namespace_token_(task_graph_runner->GetNamespaceToken()), | |
86 resource_provider_(resource_provider), | |
87 preferred_tile_format_(preferred_tile_format) {} | 80 preferred_tile_format_(preferred_tile_format) {} |
88 | 81 |
89 ZeroCopyTileTaskWorkerPool::~ZeroCopyTileTaskWorkerPool() { | 82 ZeroCopyRasterBufferProvider::~ZeroCopyRasterBufferProvider() {} |
| 83 |
| 84 std::unique_ptr<RasterBuffer> |
| 85 ZeroCopyRasterBufferProvider::AcquireBufferForRaster( |
| 86 const Resource* resource, |
| 87 uint64_t resource_content_id, |
| 88 uint64_t previous_content_id) { |
| 89 return base::WrapUnique<RasterBuffer>( |
| 90 new RasterBufferImpl(resource_provider_, resource)); |
90 } | 91 } |
91 | 92 |
92 void ZeroCopyTileTaskWorkerPool::Shutdown() { | 93 void ZeroCopyRasterBufferProvider::ReleaseBufferForRaster( |
93 TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::Shutdown"); | 94 std::unique_ptr<RasterBuffer> buffer) { |
94 | 95 // Nothing to do here. RasterBufferImpl destructor cleans up after itself. |
95 TaskGraph empty; | |
96 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); | |
97 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); | |
98 } | 96 } |
99 | 97 |
100 void ZeroCopyTileTaskWorkerPool::ScheduleTasks(TaskGraph* graph) { | 98 void ZeroCopyRasterBufferProvider::OrderingBarrier() { |
101 TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::ScheduleTasks"); | 99 // No need to sync resources as this provider does not use GL context. |
102 | |
103 ScheduleTasksOnOriginThread(this, graph); | |
104 task_graph_runner_->ScheduleTasks(namespace_token_, graph); | |
105 } | 100 } |
106 | 101 |
107 void ZeroCopyTileTaskWorkerPool::CheckForCompletedTasks() { | 102 ResourceFormat ZeroCopyRasterBufferProvider::GetResourceFormat( |
108 TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::CheckForCompletedTasks"); | |
109 | |
110 task_graph_runner_->CollectCompletedTasks(namespace_token_, | |
111 &completed_tasks_); | |
112 for (Task::Vector::const_iterator it = completed_tasks_.begin(); | |
113 it != completed_tasks_.end(); ++it) { | |
114 TileTask* task = static_cast<TileTask*>(it->get()); | |
115 | |
116 task->WillComplete(); | |
117 task->CompleteOnOriginThread(this); | |
118 task->DidComplete(); | |
119 } | |
120 completed_tasks_.clear(); | |
121 } | |
122 | |
123 ResourceFormat ZeroCopyTileTaskWorkerPool::GetResourceFormat( | |
124 bool must_support_alpha) const { | 103 bool must_support_alpha) const { |
125 if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) && | 104 if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) && |
126 (DoesResourceFormatSupportAlpha(preferred_tile_format_) || | 105 (DoesResourceFormatSupportAlpha(preferred_tile_format_) || |
127 !must_support_alpha)) { | 106 !must_support_alpha)) { |
128 return preferred_tile_format_; | 107 return preferred_tile_format_; |
129 } | 108 } |
130 | 109 |
131 return resource_provider_->best_texture_format(); | 110 return resource_provider_->best_texture_format(); |
132 } | 111 } |
133 | 112 |
134 bool ZeroCopyTileTaskWorkerPool::GetResourceRequiresSwizzle( | 113 bool ZeroCopyRasterBufferProvider::GetResourceRequiresSwizzle( |
135 bool must_support_alpha) const { | 114 bool must_support_alpha) const { |
136 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); | 115 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); |
137 } | 116 } |
138 | 117 |
139 RasterBufferProvider* ZeroCopyTileTaskWorkerPool::AsRasterBufferProvider() { | 118 void ZeroCopyRasterBufferProvider::Shutdown() {} |
140 return this; | |
141 } | |
142 | |
143 std::unique_ptr<RasterBuffer> | |
144 ZeroCopyTileTaskWorkerPool::AcquireBufferForRaster( | |
145 const Resource* resource, | |
146 uint64_t resource_content_id, | |
147 uint64_t previous_content_id) { | |
148 return base::WrapUnique<RasterBuffer>( | |
149 new RasterBufferImpl(resource_provider_, resource)); | |
150 } | |
151 | |
152 void ZeroCopyTileTaskWorkerPool::ReleaseBufferForRaster( | |
153 std::unique_ptr<RasterBuffer> buffer) { | |
154 // Nothing to do here. RasterBufferImpl destructor cleans up after itself. | |
155 } | |
156 | 119 |
157 } // namespace cc | 120 } // namespace cc |
OLD | NEW |