components/mus/gles2/command_buffer_impl.cc

   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 "components/mus/gles2/command_buffer_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "components/mus/gles2/command_buffer_driver.h"
  10 #include "components/mus/gles2/command_buffer_impl_observer.h"
  11 #include "components/mus/gles2/gpu_state.h"
  12 #include "gpu/command_buffer/service/sync_point_manager.h"
  13
  14 namespace mus {
  15
  16 namespace {
  17
  18 void RunCallback(const mojo::Callback<void()>& callback) {
  19   callback.Run();
  20 }
  21
  22 }  // namespace
  23
  24 class CommandBufferImpl::CommandBufferDriverClientImpl
  25     : public CommandBufferDriver::Client {
  26  public:
  27   explicit CommandBufferDriverClientImpl(CommandBufferImpl* command_buffer)
  28       : command_buffer_(command_buffer) {}
  29
  30  private:
  31   void DidLoseContext() override { command_buffer_->DidLoseContext(); }
  32
  33   CommandBufferImpl* command_buffer_;
  34
  35   DISALLOW_COPY_AND_ASSIGN(CommandBufferDriverClientImpl);
  36 };
  37
  38 CommandBufferImpl::CommandBufferImpl(
  39     mojo::InterfaceRequest<mojo::CommandBuffer> request,
  40     scoped_refptr<GpuState> gpu_state,
  41     scoped_ptr<CommandBufferDriver> driver)
  42     : gpu_state_(gpu_state),
  43       driver_task_runner_(base::MessageLoop::current()->task_runner()),
  44       driver_(driver.Pass()),
  45       binding_(this),
  46       observer_(nullptr),
  47       weak_ptr_factory_(this) {
  48   driver_->set_client(make_scoped_ptr(new CommandBufferDriverClientImpl(this)));
  49
  50   gpu_state_->control_task_runner()->PostTask(
  51       FROM_HERE,
  52       base::Bind(&CommandBufferImpl::BindToRequest,
  53                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&request)));
  54 }
  55
  56 void CommandBufferImpl::Initialize(
  57     mojo::CommandBufferSyncClientPtr sync_client,
  58     mojo::CommandBufferSyncPointClientPtr sync_point_client,
  59     mojo::CommandBufferLostContextObserverPtr loss_observer,
  60     mojo::ScopedSharedBufferHandle shared_state,
  61     mojo::Array<int32_t> attribs) {
  62   sync_point_client_ = sync_point_client.Pass();
  63   driver_task_runner_->PostTask(
  64       FROM_HERE,
  65       base::Bind(&CommandBufferDriver::Initialize,
  66                  base::Unretained(driver_.get()), base::Passed(&sync_client),
  67                  base::Passed(&loss_observer), base::Passed(&shared_state),
  68                  base::Passed(&attribs)));
  69 }
  70
  71 void CommandBufferImpl::SetGetBuffer(int32_t buffer) {
  72   driver_task_runner_->PostTask(
  73       FROM_HERE, base::Bind(&CommandBufferDriver::SetGetBuffer,
  74                             base::Unretained(driver_.get()), buffer));
  75 }
  76
  77 void CommandBufferImpl::Flush(int32_t put_offset) {
  78   driver_task_runner_->PostTask(
  79       FROM_HERE, base::Bind(&CommandBufferDriver::Flush,
  80                             base::Unretained(driver_.get()), put_offset));
  81 }
  82
  83 void CommandBufferImpl::MakeProgress(int32_t last_get_offset) {
  84   driver_task_runner_->PostTask(
  85       FROM_HERE, base::Bind(&CommandBufferDriver::MakeProgress,
  86                             base::Unretained(driver_.get()), last_get_offset));
  87 }
  88
  89 void CommandBufferImpl::RegisterTransferBuffer(
  90     int32_t id,
  91     mojo::ScopedSharedBufferHandle transfer_buffer,
  92     uint32_t size) {
  93   driver_task_runner_->PostTask(
  94       FROM_HERE, base::Bind(&CommandBufferDriver::RegisterTransferBuffer,
  95                             base::Unretained(driver_.get()), id,
  96                             base::Passed(&transfer_buffer), size));
  97 }
  98
  99 void CommandBufferImpl::DestroyTransferBuffer(int32_t id) {
 100   driver_task_runner_->PostTask(
 101       FROM_HERE, base::Bind(&CommandBufferDriver::DestroyTransferBuffer,
 102                             base::Unretained(driver_.get()), id));
 103 }
 104
 105 void CommandBufferImpl::InsertSyncPoint(bool retire) {
 106   uint32_t sync_point = gpu_state_->sync_point_manager()->GenerateSyncPoint();
 107   sync_point_client_->DidInsertSyncPoint(sync_point);
 108   if (retire) {
 109     driver_task_runner_->PostTask(
 110         FROM_HERE,
 111         base::Bind(&gpu::SyncPointManager::RetireSyncPoint,
 112                    base::Unretained(gpu_state_->sync_point_manager()),
 113                    sync_point));
 114   }
 115 }
 116
 117 void CommandBufferImpl::RetireSyncPoint(uint32_t sync_point) {
 118   driver_task_runner_->PostTask(
 119       FROM_HERE, base::Bind(&gpu::SyncPointManager::RetireSyncPoint,
 120                             base::Unretained(gpu_state_->sync_point_manager()),
 121                             sync_point));
 122 }
 123
 124 void CommandBufferImpl::Echo(const mojo::Callback<void()>& callback) {
 125   driver_task_runner_->PostTaskAndReply(FROM_HERE, base::Bind(&base::DoNothing),
 126                                         base::Bind(&RunCallback, callback));
 127 }
 128
 129 void CommandBufferImpl::CreateImage(int32_t id,
 130                                     mojo::ScopedHandle memory_handle,
 131                                     int32 type,
 132                                     mojo::SizePtr size,
 133                                     int32_t format,
 134                                     int32_t internal_format) {
 135   driver_task_runner_->PostTask(
 136       FROM_HERE, base::Bind(&CommandBufferDriver::CreateImage,
 137                             base::Unretained(driver_.get()), id,
 138                             base::Passed(&memory_handle), type,
 139                             base::Passed(&size), format, internal_format));
 140 }
 141
 142 void CommandBufferImpl::DestroyImage(int32_t id) {
 143   driver_task_runner_->PostTask(
 144       FROM_HERE, base::Bind(&CommandBufferDriver::DestroyImage,
 145                             base::Unretained(driver_.get()), id));
 146 }
 147
 148 CommandBufferImpl::~CommandBufferImpl() {
 149   if (observer_)
 150     observer_->OnCommandBufferImplDestroyed();
 151 }
 152
 153 void CommandBufferImpl::BindToRequest(
 154     mojo::InterfaceRequest<mojo::CommandBuffer> request) {
 155   binding_.Bind(request.Pass());
 156   binding_.set_connection_error_handler([this]() { OnConnectionError(); });
 157 }
 158
 159 void CommandBufferImpl::OnConnectionError() {
 160   // OnConnectionError() is called on the control thread |control_task_runner|.
 161   // sync_point_client_ is assigned and accessed on the control thread and so it
 162   // should also be destroyed on the control because InterfacePtrs are thread-
 163   // hostile.
 164   sync_point_client_.reset();
 165
 166   // Objects we own (such as CommandBufferDriver) need to be destroyed on the
 167   // thread we were created on.
 168   driver_task_runner_->DeleteSoon(FROM_HERE, this);
 169 }
 170
 171 void CommandBufferImpl::DidLoseContext() {
 172   OnConnectionError();
 173 }
 174
 175 }  // namespace mus