mus: Modify mojo command buffer to match current chrome gpu ipc.

components/mus/gles2/command_buffer_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/mus/gles2/command_buffer_impl.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "components/mus/gles2/command_buffer_driver.h"
-#include "components/mus/gles2/command_buffer_impl_observer.h"
 #include "components/mus/gles2/command_buffer_type_conversions.h"
 #include "components/mus/gles2/gpu_state.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 
 namespace mus {
 
 namespace {
 
 uint64_t g_next_command_buffer_id = 0;
 
@@ skipping 24 matching lines @@
   void UpdateVSyncParameters(int64_t timebase, int64_t interval) override {}
 
   CommandBufferImpl* command_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBufferDriverClientImpl);
 };
 
 CommandBufferImpl::CommandBufferImpl(
     mojo::InterfaceRequest<mus::mojom::CommandBuffer> request,
     scoped_refptr<GpuState> gpu_state)
-    : gpu_state_(gpu_state), observer_(nullptr) {
+    : gpu_state_(gpu_state) {
   // Bind |CommandBufferImpl| to the |request| in the GPU control thread.
   gpu_state_->control_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CommandBufferImpl::BindToRequest,
                  base::Unretained(this), base::Passed(&request)));
 }
 
 void CommandBufferImpl::DidLoseContext(uint32_t reason) {
   driver_->set_client(nullptr);
-  loss_observer_->DidLoseContext(reason);
+  client_->Destroyed(reason, gpu::error::kLostContext);
 }
 
 CommandBufferImpl::~CommandBufferImpl() {
-  if (observer_)
-    observer_->OnCommandBufferImplDestroyed();
 }
 
 void CommandBufferImpl::Initialize(
-    mus::mojom::CommandBufferLostContextObserverPtr loss_observer,
+    mus::mojom::CommandBufferClientPtr client,
     mojo::ScopedSharedBufferHandle shared_state,
     mojo::Array<int32_t> attribs,
     const mojom::CommandBuffer::InitializeCallback& callback) {
   gpu_state_->command_buffer_task_runner()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CommandBufferImpl::InitializeOnGpuThread,
-                 base::Unretained(this), base::Passed(&loss_observer),
+                 base::Unretained(this), base::Passed(&client),
                  base::Passed(&shared_state), base::Passed(&attribs),
                  base::Bind(&RunInitializeCallback, callback)));
 }
 
 void CommandBufferImpl::SetGetBuffer(int32_t buffer) {
   gpu_state_->command_buffer_task_runner()->PostTask(
       driver_.get(), base::Bind(&CommandBufferImpl::SetGetBufferOnGpuThread,
                                 base::Unretained(this), buffer));
 }
 
@@ skipping 46 matching lines @@
                  base::Unretained(this), id, base::Passed(&memory_handle), type,
                  base::Passed(&size), format, internal_format));
 }
 
 void CommandBufferImpl::DestroyImage(int32_t id) {
   gpu_state_->command_buffer_task_runner()->PostTask(
       driver_.get(), base::Bind(&CommandBufferImpl::DestroyImageOnGpuThread,
                                 base::Unretained(this), id));
 }
 
+void CommandBufferImpl::CreateStreamTexture(
+    uint32_t client_texture_id,
+    const mojom::CommandBuffer::CreateStreamTextureCallback& callback) {
+  NOTIMPLEMENTED();
+}
+
+void CommandBufferImpl::ProduceFrontBuffer(const gpu::Mailbox& mailbox) {
+  NOTIMPLEMENTED();
+}
+
+void CommandBufferImpl::SignalQuery(uint32_t query, uint32_t signal_id) {
+  NOTIMPLEMENTED();
+}
+
+void CommandBufferImpl::SignalSyncToken(const gpu::SyncToken& sync_token,
+                                        uint32_t signal_id) {
+  NOTIMPLEMENTED();
+}
+
+void CommandBufferImpl::WaitForGetOffsetInRange(
+    int32_t start, int32_t end,
+    const mojom::CommandBuffer::WaitForGetOffsetInRangeCallback& callback) {
+  NOTIMPLEMENTED();
+}
+
+void CommandBufferImpl::WaitForTokenInRange(
+    int32_t start, int32_t end,
+    const mojom::CommandBuffer::WaitForGetOffsetInRangeCallback& callback) {
+  NOTIMPLEMENTED();
+}
+
 void CommandBufferImpl::BindToRequest(
     mojo::InterfaceRequest<mus::mojom::CommandBuffer> request) {
   binding_.reset(
       new mojo::Binding<mus::mojom::CommandBuffer>(this, std::move(request)));
   binding_->set_connection_error_handler([this]() { OnConnectionError(); });
 }
 
 void CommandBufferImpl::InitializeOnGpuThread(
-    mojom::CommandBufferLostContextObserverPtr loss_observer,
+    mojom::CommandBufferClientPtr client,
     mojo::ScopedSharedBufferHandle shared_state,
     mojo::Array<int32_t> attribs,
     const base::Callback<
         void(mojom::CommandBufferInitializeResultPtr)>& callback) {
   DCHECK(!driver_);
   driver_.reset(new CommandBufferDriver(
       gpu::CommandBufferNamespace::MOJO, ++g_next_command_buffer_id,
       gfx::kNullAcceleratedWidget, gpu_state_));
   driver_->set_client(make_scoped_ptr(new CommandBufferDriverClientImpl(this)));
-  loss_observer_ = mojo::MakeProxy(loss_observer.PassInterface());
+  client_ = mojo::MakeProxy(client.PassInterface());
   bool result =
       driver_->Initialize(std::move(shared_state), std::move(attribs));
   mojom::CommandBufferInitializeResultPtr initialize_result;
   if (result) {
     initialize_result = mojom::CommandBufferInitializeResult::New();
     initialize_result->command_buffer_namespace = driver_->GetNamespaceID();
     initialize_result->command_buffer_id = driver_->GetCommandBufferID();
     initialize_result->capabilities = driver_->GetCapabilities();
   }
   gpu_state_->control_task_runner()->PostTask(
@@ skipping 77 matching lines @@
       driver_.get(), base::Bind(&CommandBufferImpl::DeleteOnGpuThread,
                                 base::Unretained(this)));
 }
 
 bool CommandBufferImpl::DeleteOnGpuThread() {
   delete this;
   return true;
 }
 
 }  // namespace mus