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     : gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
  20       gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
  21       mailbox_manager_(mailbox_manager),
  22       query_manager_(query_manager) {
  23 }
  24
  25 GpuControlService::~GpuControlService() {
  26 }
  27
  28 bool GpuControlService::SupportsGpuMemoryBuffer() {
  29   return gpu_memory_buffer_manager_ && gpu_memory_buffer_factory_;
  30 }
  31
  32 gfx::GpuMemoryBuffer* GpuControlService::CreateGpuMemoryBuffer(
  33     size_t width,
  34     size_t height,
  35     unsigned internalformat,
  36     int32* id) {
  37   *id = -1;
  38
  39   CHECK(gpu_memory_buffer_factory_) << "No GPU memory buffer factory provided";
  40   linked_ptr<gfx::GpuMemoryBuffer> buffer = make_linked_ptr(
  41       gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(width,
  42                                                         height,
  43                                                         internalformat));
  44   if (!buffer.get())
  45     return NULL;
  46
  47   static int32 next_id = 1;
  48   *id = next_id++;
  49
  50   if (!RegisterGpuMemoryBuffer(*id,
  51                                buffer->GetHandle(),
  52                                width,
  53                                height,
  54                                internalformat)) {
  55     *id = -1;
  56     return NULL;
  57   }
  58
  59   gpu_memory_buffers_[*id] = buffer;
  60   return buffer.get();
  61 }
  62
  63 void GpuControlService::DestroyGpuMemoryBuffer(int32 id) {
  64   GpuMemoryBufferMap::iterator it = gpu_memory_buffers_.find(id);
  65   if (it != gpu_memory_buffers_.end())
  66     gpu_memory_buffers_.erase(it);
  67
  68   gpu_memory_buffer_manager_->DestroyGpuMemoryBuffer(id);
  69 }
  70
  71 uint32 GpuControlService::InsertSyncPoint() {
  72   NOTREACHED();
  73   return 0u;
  74 }
  75
  76 void GpuControlService::SignalSyncPoint(uint32 sync_point,
  77                                         const base::Closure& callback) {
  78   NOTREACHED();
  79 }
  80
  81 void GpuControlService::SignalQuery(uint32 query_id,
  82                                     const base::Closure& callback) {
  83   DCHECK(query_manager_);
  84   gles2::QueryManager::Query* query = query_manager_->GetQuery(query_id);
  85   if (!query)
  86     callback.Run();
  87   else
  88     query->AddCallback(callback);
  89 }
  90
  91 void GpuControlService::SendManagedMemoryStats(
  92     const ManagedMemoryStats& stats) {
  93   NOTREACHED();
  94 }
  95
  96 bool GpuControlService::RegisterGpuMemoryBuffer(
  97     int32 id,
  98     gfx::GpuMemoryBufferHandle buffer,
  99     size_t width,
 100     size_t height,
 101     unsigned internalformat) {
 102   return gpu_memory_buffer_manager_->RegisterGpuMemoryBuffer(id,
 103                                                              buffer,
 104                                                              width,
 105                                                              height,
 106                                                              internalformat);
 107 }
 108
 109 bool GpuControlService::GenerateMailboxNames(
 110     unsigned num, std::vector<gpu::Mailbox>* names) {
 111   DCHECK(names->empty());
 112   names->resize(num);
 113   for (unsigned i = 0; i < num; ++i) {
 114     gles2::MailboxName name;
 115     mailbox_manager_->GenerateMailboxName(&name);
 116     (*names)[i].SetName(name.key);
 117   }
 118   return true;
 119 }
 120
 121 }  // namespace gpu