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

mojo/gles2/command_buffer_client_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 "mojo/gles2/command_buffer_client_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 53 matching lines @@
 
 void CommandBufferDelegate::ContextLost() {}
 
 CommandBufferClientImpl::CommandBufferClientImpl(
     CommandBufferDelegate* delegate,
     const std::vector<int32_t>& attribs,
     const MojoAsyncWaiter* async_waiter,
     mojo::ScopedMessagePipeHandle command_buffer_handle)
     : delegate_(delegate),
       attribs_(attribs),
-      observer_binding_(this),
+      client_binding_(this),
       command_buffer_id_(0),
       shared_state_(NULL),
       last_put_offset_(-1),
       next_transfer_buffer_id_(0),
       next_image_id_(0),
       next_fence_sync_release_(1),
       flushed_fence_sync_release_(0),
       async_waiter_(async_waiter) {
   command_buffer_.Bind(mojo::InterfacePtrInfo<mus::mojom::CommandBuffer>(
                            std::move(command_buffer_handle), 0u),
                        async_waiter);
   command_buffer_.set_connection_error_handler(
-      [this]() { DidLoseContext(gpu::error::kUnknown); });
+      [this]() { Destroyed(gpu::error::kUnknown, gpu::error::kLostContext); });
 }
 
 CommandBufferClientImpl::~CommandBufferClientImpl() {}
 
 bool CommandBufferClientImpl::Initialize() {
   const size_t kSharedStateSize = sizeof(gpu::CommandBufferSharedState);
   void* memory = NULL;
   mojo::ScopedSharedBufferHandle duped;
   bool result = CreateMapAndDupSharedBuffer(
       kSharedStateSize, &memory, &shared_state_handle_, &duped);
   if (!result)
     return false;
 
   shared_state_ = static_cast<gpu::CommandBufferSharedState*>(memory);
 
   shared_state()->Initialize();
 
-  mus::mojom::CommandBufferLostContextObserverPtr observer_ptr;
-  observer_binding_.Bind(GetProxy(&observer_ptr), async_waiter_);
+  mus::mojom::CommandBufferClientPtr client_ptr;
+  client_binding_.Bind(GetProxy(&client_ptr), async_waiter_);
 
   mus::mojom::CommandBufferInitializeResultPtr initialize_result;
   command_buffer_->Initialize(
-      std::move(observer_ptr), std::move(duped),
+      std::move(client_ptr), std::move(duped),
       mojo::Array<int32_t>::From(attribs_),
       base::Bind(&InitializeCallback, &initialize_result));
 
   base::ThreadRestrictions::ScopedAllowWait wait;
   if (!command_buffer_.WaitForIncomingResponse()) {
     VLOG(1) << "Channel encountered error while creating command buffer.";
     return false;
   }
 
   if (!initialize_result) {
@@ skipping 157 matching lines @@
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
 void CommandBufferClientImpl::SignalQuery(uint32_t query,
                                           const base::Closure& callback) {
   // TODO(piman)
   NOTIMPLEMENTED();
 }
 
-void CommandBufferClientImpl::DidLoseContext(int32_t lost_reason) {
-  last_state_.error = gpu::error::kLostContext;
+void CommandBufferClientImpl::Destroyed(int32_t lost_reason, int32_t error) {
   last_state_.context_lost_reason =
       static_cast<gpu::error::ContextLostReason>(lost_reason);
+  last_state_.error = static_cast<gpu::error::Error>(error);
   delegate_->ContextLost();
 }
 
+void CommandBufferClientImpl::SignalAck(uint32_t id) {
+}
+
+void CommandBufferClientImpl::SwapBuffersCompleted(int32_t result) {
+}
+
+void CommandBufferClientImpl::UpdateState(
+    const gpu::CommandBuffer::State& state) {
+}
+
+void CommandBufferClientImpl::UpdateVSyncParameters(int64_t timebase,
+                                                    int64_t interval) {
+}
+
 void CommandBufferClientImpl::TryUpdateState() {
   if (last_state_.error == gpu::error::kNoError)
     shared_state()->Read(&last_state_);
 }
 
 void CommandBufferClientImpl::MakeProgressAndUpdateState() {
   gpu::CommandBuffer::State state;
   command_buffer_->MakeProgress(
       last_state_.get_offset,
       base::Bind(&MakeProgressCallback, &state));
 
   base::ThreadRestrictions::ScopedAllowWait wait;
   if (!command_buffer_.WaitForIncomingResponse()) {
     VLOG(1) << "Channel encountered error while waiting for command buffer.";
     // TODO(piman): is it ok for this to re-enter?
-    DidLoseContext(gpu::error::kUnknown);
+    Destroyed(gpu::error::kUnknown, gpu::error::kLostContext);
     return;
   }
 
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }
 
 void CommandBufferClientImpl::SetLock(base::Lock* lock) {
 }
 
@@ skipping 49 matching lines @@
 
   // It is also safe to wait on the same context.
   if (sync_token->namespace_id() == gpu::CommandBufferNamespace::MOJO &&
       sync_token->command_buffer_id() == GetCommandBufferID())
     return true;
 
   return false;
 }
 
 }  // namespace gles2