src/gpu/command_buffer/service/gpu_control_service.cc

   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 "gpu/command_buffer/service/gpu_control_service.h"
   6
   7 #include "gpu/command_buffer/client/gpu_memory_buffer_factory.h"
   8 #include "gpu/command_buffer/service/gpu_memory_buffer_manager.h"
   9 #include "gpu/command_buffer/service/mailbox_manager.h"
  10 #include "gpu/command_buffer/service/query_manager.h"
  11
  12 namespace gpu {
  13
  14 GpuControlService::GpuControlService(
  15     GpuMemoryBufferManagerInterface* gpu_memory_buffer_manager,
  16     GpuMemoryBufferFactory* gpu_memory_buffer_factory,
  17     gles2::MailboxManager* mailbox_manager,
  18     gles2::QueryManager* query_manager,
  19     const gpu::Capabilities& decoder_capabilities)
  20     : gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
  21       gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
  22       mailbox_manager_(mailbox_manager),
  23       query_manager_(query_manager),
  24       capabilities_(decoder_capabilities) {
  25   capabilities_.map_image =
  26       gpu_memory_buffer_manager_ && gpu_memory_buffer_factory_;
  27 }
  28
  29 GpuControlService::~GpuControlService() {
  30 }
  31
  32 gpu::Capabilities GpuControlService::GetCapabilities() {
  33   return capabilities_;
  34 }
  35
  36 gfx::GpuMemoryBuffer* GpuControlService::CreateGpuMemoryBuffer(
  37     size_t width,
  38     size_t height,
  39     unsigned internalformat,
  40     int32* id) {
  41   *id = -1;
  42
  43   CHECK(gpu_memory_buffer_factory_) << "No GPU memory buffer factory provided";
  44   linked_ptr<gfx::GpuMemoryBuffer> buffer = make_linked_ptr(
  45       gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(width,
  46                                                         height,
  47                                                         internalformat));
  48   if (!buffer.get())
  49     return NULL;
  50
  51   static int32 next_id = 1;
  52   *id = next_id++;
  53
  54   if (!RegisterGpuMemoryBuffer(*id,
  55                                buffer->GetHandle(),
  56                                width,
  57                                height,
  58                                internalformat)) {
  59     *id = -1;
  60     return NULL;
  61   }
  62
  63   gpu_memory_buffers_[*id] = buffer;
  64   return buffer.get();
  65 }
  66
  67 void GpuControlService::DestroyGpuMemoryBuffer(int32 id) {
  68   GpuMemoryBufferMap::iterator it = gpu_memory_buffers_.find(id);
  69   if (it != gpu_memory_buffers_.end())
  70     gpu_memory_buffers_.erase(it);
  71
  72   gpu_memory_buffer_manager_->DestroyGpuMemoryBuffer(id);
  73 }
  74
  75 uint32 GpuControlService::InsertSyncPoint() {
  76   NOTREACHED();
  77   return 0u;
  78 }
  79
  80 void GpuControlService::SignalSyncPoint(uint32 sync_point,
  81                                         const base::Closure& callback) {
  82   NOTREACHED();
  83 }
  84
  85 void GpuControlService::SignalQuery(uint32 query_id,
  86                                     const base::Closure& callback) {
  87   DCHECK(query_manager_);
  88   gles2::QueryManager::Query* query = query_manager_->GetQuery(query_id);
  89   if (!query)
  90     callback.Run();
  91   else
  92     query->AddCallback(callback);
  93 }
  94
  95 void GpuControlService::SetSurfaceVisible(bool visible) {
  96   NOTREACHED();
  97 }
  98
  99 void GpuControlService::SendManagedMemoryStats(
 100     const ManagedMemoryStats& stats) {
 101   NOTREACHED();
 102 }
 103
 104 void GpuControlService::Echo(const base::Closure& callback) {
 105   NOTREACHED();
 106 }
 107
 108 uint32 GpuControlService::CreateStreamTexture(uint32 texture_id) {
 109   NOTREACHED();
 110   return 0;
 111 }
 112
 113 bool GpuControlService::RegisterGpuMemoryBuffer(
 114     int32 id,
 115     gfx::GpuMemoryBufferHandle buffer,
 116     size_t width,
 117     size_t height,
 118     unsigned internalformat) {
 119   return gpu_memory_buffer_manager_->RegisterGpuMemoryBuffer(id,
 120                                                              buffer,
 121                                                              width,
 122                                                              height,
 123                                                              internalformat);
 124 }
 125
 126 }  // namespace gpu