| 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 "components/view_manager/gles2/command_buffer_driver.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/macros.h" | |
| 9 #include "base/memory/shared_memory.h" | |
| 10 #include "components/view_manager/gles2/command_buffer_type_conversions.h" | |
| 11 #include "components/view_manager/gles2/gpu_memory_tracker.h" | |
| 12 #include "components/view_manager/gles2/gpu_state.h" | |
| 13 #include "components/view_manager/gles2/mojo_buffer_backing.h" | |
| 14 #include "gpu/command_buffer/common/constants.h" | |
| 15 #include "gpu/command_buffer/common/value_state.h" | |
| 16 #include "gpu/command_buffer/service/command_buffer_service.h" | |
| 17 #include "gpu/command_buffer/service/context_group.h" | |
| 18 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" | |
| 19 #include "gpu/command_buffer/service/gpu_scheduler.h" | |
| 20 #include "gpu/command_buffer/service/image_factory.h" | |
| 21 #include "gpu/command_buffer/service/image_manager.h" | |
| 22 #include "gpu/command_buffer/service/mailbox_manager.h" | |
| 23 #include "gpu/command_buffer/service/memory_tracking.h" | |
| 24 #include "gpu/command_buffer/service/sync_point_manager.h" | |
| 25 #include "gpu/command_buffer/service/transfer_buffer_manager.h" | |
| 26 #include "gpu/command_buffer/service/valuebuffer_manager.h" | |
| 27 #include "mojo/converters/geometry/geometry_type_converters.h" | |
| 28 #include "mojo/platform_handle/platform_handle_functions.h" | |
| 29 #include "ui/gfx/gpu_memory_buffer.h" | |
| 30 #include "ui/gfx/vsync_provider.h" | |
| 31 #include "ui/gl/gl_context.h" | |
| 32 #include "ui/gl/gl_image_shared_memory.h" | |
| 33 #include "ui/gl/gl_surface.h" | |
| 34 | |
| 35 namespace gles2 { | |
| 36 | |
| 37 CommandBufferDriver::Client::~Client() { | |
| 38 } | |
| 39 | |
| 40 CommandBufferDriver::CommandBufferDriver(scoped_refptr<GpuState> gpu_state) | |
| 41 : client_(nullptr), | |
| 42 gpu_state_(gpu_state), | |
| 43 weak_factory_(this) { | |
| 44 } | |
| 45 | |
| 46 CommandBufferDriver::~CommandBufferDriver() { | |
| 47 DestroyDecoder(); | |
| 48 } | |
| 49 | |
| 50 void CommandBufferDriver::Initialize( | |
| 51 mojo::CommandBufferSyncClientPtr sync_client, | |
| 52 mojo::CommandBufferLostContextObserverPtr loss_observer, | |
| 53 mojo::ScopedSharedBufferHandle shared_state) { | |
| 54 sync_client_ = sync_client.Pass(); | |
| 55 loss_observer_ = loss_observer.Pass(); | |
| 56 bool success = DoInitialize(shared_state.Pass()); | |
| 57 mojo::GpuCapabilitiesPtr capabilities = | |
| 58 success ? mojo::GpuCapabilities::From(decoder_->GetCapabilities()) | |
| 59 : nullptr; | |
| 60 sync_client_->DidInitialize(success, capabilities.Pass()); | |
| 61 } | |
| 62 | |
| 63 bool CommandBufferDriver::MakeCurrent() { | |
| 64 if (!decoder_) | |
| 65 return false; | |
| 66 if (decoder_->MakeCurrent()) | |
| 67 return true; | |
| 68 DLOG(ERROR) << "Context lost because MakeCurrent failed."; | |
| 69 gpu::error::ContextLostReason reason = | |
| 70 static_cast<gpu::error::ContextLostReason>( | |
| 71 decoder_->GetContextLostReason()); | |
| 72 command_buffer_->SetContextLostReason(reason); | |
| 73 command_buffer_->SetParseError(gpu::error::kLostContext); | |
| 74 OnContextLost(reason); | |
| 75 return false; | |
| 76 } | |
| 77 | |
| 78 bool CommandBufferDriver::DoInitialize( | |
| 79 mojo::ScopedSharedBufferHandle shared_state) { | |
| 80 surface_ = gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(1, 1)); | |
| 81 | |
| 82 if (!surface_.get()) | |
| 83 return false; | |
| 84 | |
| 85 // TODO(piman): virtual contexts, gpu preference. | |
| 86 context_ = gfx::GLContext::CreateGLContext( | |
| 87 gpu_state_->share_group(), surface_.get(), gfx::PreferIntegratedGpu); | |
| 88 if (!context_.get()) | |
| 89 return false; | |
| 90 | |
| 91 if (!context_->MakeCurrent(surface_.get())) | |
| 92 return false; | |
| 93 | |
| 94 // TODO(piman): ShaderTranslatorCache is currently per-ContextGroup but | |
| 95 // only needs to be per-thread. | |
| 96 bool bind_generates_resource = false; | |
| 97 scoped_refptr<gpu::gles2::ContextGroup> context_group = | |
| 98 new gpu::gles2::ContextGroup( | |
| 99 gpu_state_->mailbox_manager(), new GpuMemoryTracker, | |
| 100 new gpu::gles2::ShaderTranslatorCache, | |
| 101 new gpu::gles2::FramebufferCompletenessCache, nullptr, nullptr, | |
| 102 nullptr, bind_generates_resource); | |
| 103 | |
| 104 command_buffer_.reset( | |
| 105 new gpu::CommandBufferService(context_group->transfer_buffer_manager())); | |
| 106 bool result = command_buffer_->Initialize(); | |
| 107 DCHECK(result); | |
| 108 | |
| 109 decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group.get())); | |
| 110 scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(), decoder_.get(), | |
| 111 decoder_.get())); | |
| 112 decoder_->set_engine(scheduler_.get()); | |
| 113 decoder_->SetResizeCallback( | |
| 114 base::Bind(&CommandBufferDriver::OnResize, base::Unretained(this))); | |
| 115 decoder_->SetWaitSyncPointCallback(base::Bind( | |
| 116 &CommandBufferDriver::OnWaitSyncPoint, base::Unretained(this))); | |
| 117 | |
| 118 gpu::gles2::DisallowedFeatures disallowed_features; | |
| 119 | |
| 120 // TODO(piman): attributes. | |
| 121 std::vector<int32> attrib_vector; | |
| 122 if (!decoder_->Initialize(surface_, context_, false /* offscreen */, | |
| 123 gfx::Size(1, 1), disallowed_features, | |
| 124 attrib_vector)) | |
| 125 return false; | |
| 126 | |
| 127 command_buffer_->SetPutOffsetChangeCallback(base::Bind( | |
| 128 &gpu::GpuScheduler::PutChanged, base::Unretained(scheduler_.get()))); | |
| 129 command_buffer_->SetGetBufferChangeCallback(base::Bind( | |
| 130 &gpu::GpuScheduler::SetGetBuffer, base::Unretained(scheduler_.get()))); | |
| 131 command_buffer_->SetParseErrorCallback( | |
| 132 base::Bind(&CommandBufferDriver::OnParseError, base::Unretained(this))); | |
| 133 | |
| 134 // TODO(piman): other callbacks | |
| 135 | |
| 136 const size_t kSize = sizeof(gpu::CommandBufferSharedState); | |
| 137 scoped_ptr<gpu::BufferBacking> backing( | |
| 138 gles2::MojoBufferBacking::Create(shared_state.Pass(), kSize)); | |
| 139 if (!backing) | |
| 140 return false; | |
| 141 | |
| 142 command_buffer_->SetSharedStateBuffer(backing.Pass()); | |
| 143 return true; | |
| 144 } | |
| 145 | |
| 146 void CommandBufferDriver::SetGetBuffer(int32_t buffer) { | |
| 147 command_buffer_->SetGetBuffer(buffer); | |
| 148 } | |
| 149 | |
| 150 void CommandBufferDriver::Flush(int32_t put_offset) { | |
| 151 if (!context_) | |
| 152 return; | |
| 153 if (!context_->MakeCurrent(surface_.get())) { | |
| 154 DLOG(WARNING) << "Context lost"; | |
| 155 OnContextLost(gpu::error::kUnknown); | |
| 156 return; | |
| 157 } | |
| 158 command_buffer_->Flush(put_offset); | |
| 159 } | |
| 160 | |
| 161 void CommandBufferDriver::MakeProgress(int32_t last_get_offset) { | |
| 162 // TODO(piman): handle out-of-order. | |
| 163 sync_client_->DidMakeProgress( | |
| 164 mojo::CommandBufferState::From(command_buffer_->GetLastState())); | |
| 165 } | |
| 166 | |
| 167 void CommandBufferDriver::RegisterTransferBuffer( | |
| 168 int32_t id, | |
| 169 mojo::ScopedSharedBufferHandle transfer_buffer, | |
| 170 uint32_t size) { | |
| 171 // Take ownership of the memory and map it into this process. | |
| 172 // This validates the size. | |
| 173 scoped_ptr<gpu::BufferBacking> backing( | |
| 174 gles2::MojoBufferBacking::Create(transfer_buffer.Pass(), size)); | |
| 175 if (!backing) { | |
| 176 DVLOG(0) << "Failed to map shared memory."; | |
| 177 return; | |
| 178 } | |
| 179 command_buffer_->RegisterTransferBuffer(id, backing.Pass()); | |
| 180 } | |
| 181 | |
| 182 void CommandBufferDriver::DestroyTransferBuffer(int32_t id) { | |
| 183 command_buffer_->DestroyTransferBuffer(id); | |
| 184 } | |
| 185 | |
| 186 void CommandBufferDriver::Echo(const mojo::Callback<void()>& callback) { | |
| 187 callback.Run(); | |
| 188 } | |
| 189 | |
| 190 void CommandBufferDriver::CreateImage(int32_t id, | |
| 191 mojo::ScopedHandle memory_handle, | |
| 192 int32 type, | |
| 193 mojo::SizePtr size, | |
| 194 int32_t format, | |
| 195 int32_t internal_format) { | |
| 196 if (!MakeCurrent()) | |
| 197 return; | |
| 198 | |
| 199 gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager(); | |
| 200 if (image_manager->LookupImage(id)) { | |
| 201 LOG(ERROR) << "Image already exists with same ID."; | |
| 202 return; | |
| 203 } | |
| 204 | |
| 205 gfx::BufferFormat gpu_format = static_cast<gfx::BufferFormat>(format); | |
| 206 if (!gpu::ImageFactory::IsGpuMemoryBufferFormatSupported( | |
| 207 gpu_format, decoder_->GetCapabilities())) { | |
| 208 LOG(ERROR) << "Format is not supported."; | |
| 209 return; | |
| 210 } | |
| 211 | |
| 212 gfx::Size gfx_size = size.To<gfx::Size>(); | |
| 213 if (!gpu::ImageFactory::IsImageSizeValidForGpuMemoryBufferFormat( | |
| 214 gfx_size, gpu_format)) { | |
| 215 LOG(ERROR) << "Invalid image size for format."; | |
| 216 return; | |
| 217 } | |
| 218 | |
| 219 if (!gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat( | |
| 220 internal_format, gpu_format)) { | |
| 221 LOG(ERROR) << "Incompatible image format."; | |
| 222 return; | |
| 223 } | |
| 224 | |
| 225 if (type != gfx::SHARED_MEMORY_BUFFER) { | |
| 226 NOTIMPLEMENTED(); | |
| 227 return; | |
| 228 } | |
| 229 | |
| 230 gfx::GpuMemoryBufferHandle gfx_handle; | |
| 231 // TODO(jam): create mojo enum for this and converter | |
| 232 gfx_handle.type = static_cast<gfx::GpuMemoryBufferType>(type); | |
| 233 gfx_handle.id = gfx::GpuMemoryBufferId(id); | |
| 234 | |
| 235 MojoPlatformHandle platform_handle; | |
| 236 MojoResult extract_result = MojoExtractPlatformHandle( | |
| 237 memory_handle.release().value(), | |
| 238 &platform_handle); | |
| 239 if (extract_result != MOJO_RESULT_OK) { | |
| 240 NOTREACHED(); | |
| 241 return; | |
| 242 } | |
| 243 | |
| 244 #if defined(OS_WIN) | |
| 245 gfx_handle.handle = platform_handle; | |
| 246 #else | |
| 247 gfx_handle.handle = base::FileDescriptor(platform_handle, false); | |
| 248 #endif | |
| 249 | |
| 250 scoped_refptr<gfx::GLImageSharedMemory> image = | |
| 251 new gfx::GLImageSharedMemory(gfx_size, internal_format); | |
| 252 // TODO(jam): also need a mojo enum for this enum | |
| 253 if (!image->Initialize(gfx_handle, gpu_format)) { | |
| 254 NOTREACHED(); | |
| 255 return; | |
| 256 } | |
| 257 | |
| 258 image_manager->AddImage(image.get(), id); | |
| 259 } | |
| 260 | |
| 261 void CommandBufferDriver::DestroyImage(int32_t id) { | |
| 262 gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager(); | |
| 263 if (!image_manager->LookupImage(id)) { | |
| 264 LOG(ERROR) << "Image with ID doesn't exist."; | |
| 265 return; | |
| 266 } | |
| 267 if (!MakeCurrent()) | |
| 268 return; | |
| 269 image_manager->RemoveImage(id); | |
| 270 } | |
| 271 | |
| 272 void CommandBufferDriver::OnParseError() { | |
| 273 gpu::CommandBuffer::State state = command_buffer_->GetLastState(); | |
| 274 OnContextLost(state.context_lost_reason); | |
| 275 } | |
| 276 | |
| 277 void CommandBufferDriver::OnResize(gfx::Size size, float scale_factor) { | |
| 278 surface_->Resize(size); | |
| 279 } | |
| 280 | |
| 281 bool CommandBufferDriver::OnWaitSyncPoint(uint32_t sync_point) { | |
| 282 if (!sync_point) | |
| 283 return true; | |
| 284 if (gpu_state_->sync_point_manager()->IsSyncPointRetired(sync_point)) | |
| 285 return true; | |
| 286 scheduler_->SetScheduled(false); | |
| 287 gpu_state_->sync_point_manager()->AddSyncPointCallback( | |
| 288 sync_point, base::Bind(&CommandBufferDriver::OnSyncPointRetired, | |
| 289 weak_factory_.GetWeakPtr())); | |
| 290 return scheduler_->IsScheduled(); | |
| 291 } | |
| 292 | |
| 293 void CommandBufferDriver::OnSyncPointRetired() { | |
| 294 scheduler_->SetScheduled(true); | |
| 295 } | |
| 296 | |
| 297 void CommandBufferDriver::OnContextLost(uint32_t reason) { | |
| 298 loss_observer_->DidLoseContext(reason); | |
| 299 client_->DidLoseContext(); | |
| 300 } | |
| 301 | |
| 302 void CommandBufferDriver::DestroyDecoder() { | |
| 303 if (decoder_) { | |
| 304 bool have_context = decoder_->MakeCurrent(); | |
| 305 decoder_->Destroy(have_context); | |
| 306 decoder_.reset(); | |
| 307 } | |
| 308 } | |
| 309 | |
| 310 } // namespace gles2 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1344573002:
Mandoline: Rename components/view_manager to components/mus (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master