components/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/gles2/command_buffer_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "components/gles2/command_buffer_driver.h"
  10 #include "gpu/command_buffer/service/sync_point_manager.h"
  11
  12 namespace gles2 {
  13 namespace {
  14 void DestroyDriver(scoped_ptr<CommandBufferDriver> driver) {
  15   // Just let ~scoped_ptr run.
  16 }
  17
  18 void RunCallback(const mojo::Callback<void()>& callback) {
  19   callback.Run();
  20 }
  21
  22 class CommandBufferDriverClientImpl : public CommandBufferDriver::Client {
  23  public:
  24   CommandBufferDriverClientImpl(
  25       base::WeakPtr<CommandBufferImpl> command_buffer,
  26       scoped_refptr<base::SingleThreadTaskRunner> control_task_runner)
  27       : command_buffer_(command_buffer),
  28         control_task_runner_(control_task_runner) {}
  29
  30  private:
  31   void UpdateVSyncParameters(base::TimeTicks timebase,
  32                              base::TimeDelta interval) override {
  33     control_task_runner_->PostTask(
  34         FROM_HERE, base::Bind(&CommandBufferImpl::UpdateVSyncParameters,
  35                               command_buffer_, timebase, interval));
  36   }
  37
  38   void DidLoseContext() override {
  39     control_task_runner_->PostTask(
  40         FROM_HERE, base::Bind(&CommandBufferImpl::DidLoseContext,
  41            command_buffer_));
  42   }
  43
  44   base::WeakPtr<CommandBufferImpl> command_buffer_;
  45   scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_;
  46 };
  47 }
  48
  49 CommandBufferImpl::CommandBufferImpl(
  50     mojo::InterfaceRequest<mojo::CommandBuffer> request,
  51     mojo::ViewportParameterListenerPtr listener,
  52     scoped_refptr<base::SingleThreadTaskRunner> control_task_runner,
  53     gpu::SyncPointManager* sync_point_manager,
  54     scoped_ptr<CommandBufferDriver> driver)
  55     : sync_point_manager_(sync_point_manager),
  56       driver_task_runner_(base::MessageLoop::current()->task_runner()),
  57       driver_(driver.Pass()),
  58       viewport_parameter_listener_(listener.Pass()),
  59       binding_(this),
  60       weak_factory_(this) {
  61   driver_->set_client(make_scoped_ptr(new CommandBufferDriverClientImpl(
  62       weak_factory_.GetWeakPtr(), control_task_runner)));
  63
  64   control_task_runner->PostTask(
  65       FROM_HERE, base::Bind(&CommandBufferImpl::BindToRequest,
  66                             base::Unretained(this), base::Passed(&request)));
  67 }
  68
  69 CommandBufferImpl::~CommandBufferImpl() {
  70   driver_task_runner_->PostTask(
  71       FROM_HERE, base::Bind(&DestroyDriver, base::Passed(&driver_)));
  72 }
  73
  74 void CommandBufferImpl::Initialize(
  75     mojo::CommandBufferSyncClientPtr sync_client,
  76     mojo::CommandBufferSyncPointClientPtr sync_point_client,
  77     mojo::CommandBufferLostContextObserverPtr loss_observer,
  78     mojo::ScopedSharedBufferHandle shared_state) {
  79   sync_point_client_ = sync_point_client.Pass();
  80   driver_task_runner_->PostTask(
  81       FROM_HERE,
  82       base::Bind(&CommandBufferDriver::Initialize,
  83                  base::Unretained(driver_.get()), base::Passed(&sync_client),
  84                  base::Passed(&loss_observer),
  85                  base::Passed(&shared_state)));
  86 }
  87
  88 void CommandBufferImpl::SetGetBuffer(int32_t buffer) {
  89   driver_task_runner_->PostTask(
  90       FROM_HERE, base::Bind(&CommandBufferDriver::SetGetBuffer,
  91                             base::Unretained(driver_.get()), buffer));
  92 }
  93
  94 void CommandBufferImpl::Flush(int32_t put_offset) {
  95   driver_task_runner_->PostTask(
  96       FROM_HERE, base::Bind(&CommandBufferDriver::Flush,
  97                             base::Unretained(driver_.get()), put_offset));
  98 }
  99
 100 void CommandBufferImpl::MakeProgress(int32_t last_get_offset) {
 101   driver_task_runner_->PostTask(
 102       FROM_HERE, base::Bind(&CommandBufferDriver::MakeProgress,
 103                             base::Unretained(driver_.get()), last_get_offset));
 104 }
 105
 106 void CommandBufferImpl::RegisterTransferBuffer(
 107     int32_t id,
 108     mojo::ScopedSharedBufferHandle transfer_buffer,
 109     uint32_t size) {
 110   driver_task_runner_->PostTask(
 111       FROM_HERE, base::Bind(&CommandBufferDriver::RegisterTransferBuffer,
 112                             base::Unretained(driver_.get()), id,
 113                             base::Passed(&transfer_buffer), size));
 114 }
 115
 116 void CommandBufferImpl::DestroyTransferBuffer(int32_t id) {
 117   driver_task_runner_->PostTask(
 118       FROM_HERE, base::Bind(&CommandBufferDriver::DestroyTransferBuffer,
 119                             base::Unretained(driver_.get()), id));
 120 }
 121
 122 void CommandBufferImpl::InsertSyncPoint(bool retire) {
 123   uint32_t sync_point = sync_point_manager_->GenerateSyncPoint();
 124   sync_point_client_->DidInsertSyncPoint(sync_point);
 125   if (retire) {
 126     driver_task_runner_->PostTask(
 127         FROM_HERE, base::Bind(&gpu::SyncPointManager::RetireSyncPoint,
 128                               sync_point_manager_, sync_point));
 129   }
 130 }
 131
 132 void CommandBufferImpl::RetireSyncPoint(uint32_t sync_point) {
 133   driver_task_runner_->PostTask(
 134       FROM_HERE, base::Bind(&gpu::SyncPointManager::RetireSyncPoint,
 135                             sync_point_manager_, sync_point));
 136 }
 137
 138 void CommandBufferImpl::Echo(const mojo::Callback<void()>& callback) {
 139   driver_task_runner_->PostTaskAndReply(FROM_HERE, base::Bind(&base::DoNothing),
 140                                         base::Bind(&RunCallback, callback));
 141 }
 142
 143 void CommandBufferImpl::BindToRequest(
 144     mojo::InterfaceRequest<mojo::CommandBuffer> request) {
 145   binding_.Bind(request.Pass());
 146 }
 147
 148 void CommandBufferImpl::DidLoseContext() {
 149   binding_.OnConnectionError();
 150 }
 151
 152 void CommandBufferImpl::UpdateVSyncParameters(base::TimeTicks timebase,
 153                                               base::TimeDelta interval) {
 154   if (!viewport_parameter_listener_)
 155     return;
 156   viewport_parameter_listener_->OnVSyncParametersUpdated(
 157       timebase.ToInternalValue(), interval.ToInternalValue());
 158 }
 159
 160 }  // namespace gles2