components/mus/public/interfaces View => Window

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/message_loop/message_loop.h"
 #include "components/mus/gles2/command_buffer_driver.h"
 #include "components/mus/gles2/command_buffer_impl_observer.h"
@@ skipping 18 matching lines @@
 
  private:
   void DidLoseContext() override { command_buffer_->DidLoseContext(); }
 
   CommandBufferImpl* command_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBufferDriverClientImpl);
 };
 
 CommandBufferImpl::CommandBufferImpl(
-    mojo::InterfaceRequest<mojo::CommandBuffer> request,
+    mojo::InterfaceRequest<mus::mojom::CommandBuffer> request,
     scoped_refptr<GpuState> gpu_state,
     scoped_ptr<CommandBufferDriver> driver)
     : gpu_state_(gpu_state),
       driver_task_runner_(base::MessageLoop::current()->task_runner()),
       driver_(driver.Pass()),
       observer_(nullptr),
       weak_ptr_factory_(this) {
   driver_->set_client(make_scoped_ptr(new CommandBufferDriverClientImpl(this)));
 
   gpu_state_->control_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CommandBufferImpl::BindToRequest,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&request)));
 }
 
 void CommandBufferImpl::Initialize(
-    mojo::CommandBufferSyncClientPtr sync_client,
-    mojo::CommandBufferSyncPointClientPtr sync_point_client,
-    mojo::CommandBufferLostContextObserverPtr loss_observer,
+    mus::mojom::CommandBufferSyncClientPtr sync_client,
+    mus::mojom::CommandBufferSyncPointClientPtr sync_point_client,
+    mus::mojom::CommandBufferLostContextObserverPtr loss_observer,
     mojo::ScopedSharedBufferHandle shared_state,
     mojo::Array<int32_t> attribs) {
   sync_point_client_ = sync_point_client.Pass();
   driver_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CommandBufferDriver::Initialize,
                  base::Unretained(driver_.get()),
                  base::Passed(sync_client.PassInterface()),
                  base::Passed(loss_observer.PassInterface()),
                  base::Passed(&shared_state), base::Passed(&attribs)));
@@ skipping 75 matching lines @@
       FROM_HERE, base::Bind(&CommandBufferDriver::DestroyImage,
                             base::Unretained(driver_.get()), id));
 }
 
 CommandBufferImpl::~CommandBufferImpl() {
   if (observer_)
     observer_->OnCommandBufferImplDestroyed();
 }
 
 void CommandBufferImpl::BindToRequest(
-    mojo::InterfaceRequest<mojo::CommandBuffer> request) {
-  binding_.reset(new mojo::Binding<mojo::CommandBuffer>(this, request.Pass()));
+    mojo::InterfaceRequest<mus::mojom::CommandBuffer> request) {
+  binding_.reset(
+      new mojo::Binding<mus::mojom::CommandBuffer>(this, request.Pass()));
   binding_->set_connection_error_handler([this]() { OnConnectionError(); });
 }
 
 void CommandBufferImpl::OnConnectionError() {
   // OnConnectionError() is called on the control thread |control_task_runner|.
   // sync_point_client_ is assigned and accessed on the control thread and so it
   // should also be destroyed on the control because InterfacePtrs are thread-
   // hostile.
   sync_point_client_.reset();
 
   // Before deleting, we need to delete |binding_| because it is bound to the
   // current thread (|control_task_runner|).
   binding_.reset();
 
   // Objects we own (such as CommandBufferDriver) need to be destroyed on the
   // thread we were created on.
   driver_task_runner_->DeleteSoon(FROM_HERE, this);
 }
 
 void CommandBufferImpl::DidLoseContext() {
   OnConnectionError();
 }
 
 }  // namespace mus