components/mus/public/interfaces View => Window

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 <limits>
 
 #include "base/logging.h"
 #include "base/process/process_handle.h"
@@ skipping 30 matching lines @@
   return true;
 }
 
 }  // namespace
 
 CommandBufferDelegate::~CommandBufferDelegate() {}
 
 void CommandBufferDelegate::ContextLost() {}
 
 class CommandBufferClientImpl::SyncClientImpl
-    : public mojo::CommandBufferSyncClient {
+    : public mus::mojom::CommandBufferSyncClient {
  public:
-  SyncClientImpl(mojo::CommandBufferSyncClientPtr* ptr,
+  SyncClientImpl(mus::mojom::CommandBufferSyncClientPtr* ptr,
                  const MojoAsyncWaiter* async_waiter)
       : initialized_successfully_(false), binding_(this, ptr, async_waiter) {}
 
   bool WaitForInitialization() {
     if (!binding_.WaitForIncomingMethodCall())
       return false;
     return initialized_successfully_;
   }
 
-  mojo::CommandBufferStatePtr WaitForProgress() {
+  mus::mojom::CommandBufferStatePtr WaitForProgress() {
     if (!binding_.WaitForIncomingMethodCall())
-      return mojo::CommandBufferStatePtr();
+      return mus::mojom::CommandBufferStatePtr();
     return command_buffer_state_.Pass();
   }
 
   gpu::Capabilities GetCapabilities() {
     if (capabilities_)
       return capabilities_.To<gpu::Capabilities>();
     return gpu::Capabilities();
   }
 
  private:
   // CommandBufferSyncClient methods:
   void DidInitialize(bool success,
-                     mojo::GpuCapabilitiesPtr capabilities) override {
+                     mus::mojom::GpuCapabilitiesPtr capabilities) override {
     initialized_successfully_ = success;
     capabilities_ = capabilities.Pass();
   }
-  void DidMakeProgress(mojo::CommandBufferStatePtr state) override {
+  void DidMakeProgress(mus::mojom::CommandBufferStatePtr state) override {
     command_buffer_state_ = state.Pass();
   }
 
   bool initialized_successfully_;
-  mojo::GpuCapabilitiesPtr capabilities_;
-  mojo::CommandBufferStatePtr command_buffer_state_;
-  mojo::Binding<mojo::CommandBufferSyncClient> binding_;
+  mus::mojom::GpuCapabilitiesPtr capabilities_;
+  mus::mojom::CommandBufferStatePtr command_buffer_state_;
+  mojo::Binding<mus::mojom::CommandBufferSyncClient> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncClientImpl);
 };
 
 class CommandBufferClientImpl::SyncPointClientImpl
-    : public mojo::CommandBufferSyncPointClient {
+    : public mus::mojom::CommandBufferSyncPointClient {
  public:
-  SyncPointClientImpl(mojo::CommandBufferSyncPointClientPtr* ptr,
+  SyncPointClientImpl(mus::mojom::CommandBufferSyncPointClientPtr* ptr,
                       const MojoAsyncWaiter* async_waiter)
       : sync_point_(0u), binding_(this, ptr, async_waiter) {}
 
   uint32_t WaitForInsertSyncPoint() {
     if (!binding_.WaitForIncomingMethodCall())
       return 0u;
     uint32_t result = sync_point_;
     sync_point_ = 0u;
     return result;
   }
 
  private:
   void DidInsertSyncPoint(uint32_t sync_point) override {
     sync_point_ = sync_point;
   }
 
   uint32_t sync_point_;
 
-  mojo::Binding<mojo::CommandBufferSyncPointClient> binding_;
+  mojo::Binding<mus::mojom::CommandBufferSyncPointClient> binding_;
 };
 
 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),
       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<mojo::CommandBuffer>(
+  command_buffer_.Bind(mojo::InterfacePtrInfo<mus::mojom::CommandBuffer>(
                            command_buffer_handle.Pass(), 0u),
                        async_waiter);
   command_buffer_.set_connection_error_handler(
       [this]() { DidLoseContext(gpu::error::kUnknown); });
 }
 
 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();
 
-  mojo::CommandBufferSyncClientPtr sync_client;
+  mus::mojom::CommandBufferSyncClientPtr sync_client;
   sync_client_impl_.reset(new SyncClientImpl(&sync_client, async_waiter_));
 
-  mojo::CommandBufferSyncPointClientPtr sync_point_client;
+  mus::mojom::CommandBufferSyncPointClientPtr sync_point_client;
   sync_point_client_impl_.reset(
       new SyncPointClientImpl(&sync_point_client, async_waiter_));
 
-  mojo::CommandBufferLostContextObserverPtr observer_ptr;
+  mus::mojom::CommandBufferLostContextObserverPtr observer_ptr;
   observer_binding_.Bind(GetProxy(&observer_ptr), async_waiter_);
   command_buffer_->Initialize(sync_client.Pass(),
                               sync_point_client.Pass(),
                               observer_ptr.Pass(),
                               duped.Pass(),
                               mojo::Array<int32_t>::From(attribs_));
 
   // Wait for DidInitialize to come on the sync client pipe.
   if (!sync_client_impl_->WaitForInitialization()) {
     VLOG(1) << "Channel encountered error while creating command buffer";
@@ skipping 198 matching lines @@
 }
 
 void CommandBufferClientImpl::TryUpdateState() {
   if (last_state_.error == gpu::error::kNoError)
     shared_state()->Read(&last_state_);
 }
 
 void CommandBufferClientImpl::MakeProgressAndUpdateState() {
   command_buffer_->MakeProgress(last_state_.get_offset);
 
-  mojo::CommandBufferStatePtr state = sync_client_impl_->WaitForProgress();
+  mus::mojom::CommandBufferStatePtr state =
+      sync_client_impl_->WaitForProgress();
   if (!state) {
     VLOG(1) << "Channel encountered error while waiting for command buffer";
     // TODO(piman): is it ok for this to re-enter?
     DidLoseContext(gpu::error::kUnknown);
     return;
   }
 
   if (state->generation - last_state_.generation < 0x80000000U)
     last_state_ = state.To<State>();
 }
@@ skipping 34 matching lines @@
   return IsFenceSyncFlushed(release);
 }
 
 bool CommandBufferClientImpl::CanWaitUnverifiedSyncToken(
     const gpu::SyncToken* sync_token) {
   // All sync tokens must be flushed before being waited on.
   return false;
 }
 
 }  // namespace gles2