Mojo C++ bindings: Generate InterfaceHandle<> instead of InterfacePtr<>.

services/gfx/compositor/backend/gpu_output.cc

 // Copyright 2015 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 "services/gfx/compositor/backend/gpu_output.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "services/gfx/compositor/backend/gpu_rasterizer.h"
 
 namespace compositor {
 
 template <typename T>
 static void Drop(scoped_ptr<T> ptr) {}
 
 static scoped_ptr<base::MessagePump> CreateMessagePumpMojo() {
   return base::MessageLoop::CreateMessagePumpForType(
       base::MessageLoop::TYPE_DEFAULT);
 }
 
-GpuOutput::GpuOutput(mojo::ContextProviderPtr context_provider,
-                     const SchedulerCallbacks& scheduler_callbacks,
-                     const base::Closure& error_callback)
+GpuOutput::GpuOutput(
+    mojo::InterfaceHandle<mojo::ContextProvider> context_provider,
+    const SchedulerCallbacks& scheduler_callbacks,
+    const base::Closure& error_callback)
     : frame_queue_(std::make_shared<FrameQueue>()),
-      scheduler_(std::make_shared<VsyncScheduler>(base::MessageLoop::current()
-                                                      ->task_runner(),
-                                                  scheduler_callbacks)),
+      scheduler_(std::make_shared<VsyncScheduler>(
+          base::MessageLoop::current()->task_runner(),
+          scheduler_callbacks)),
       rasterizer_delegate_(
           make_scoped_ptr(new RasterizerDelegate(frame_queue_))) {
   DCHECK(context_provider);
 
   base::Thread::Options options;
   options.message_pump_factory = base::Bind(&CreateMessagePumpMojo);
 
   rasterizer_thread_.reset(new base::Thread("gpu_rasterizer"));
   rasterizer_thread_->StartWithOptions(options);
   rasterizer_task_runner_ = rasterizer_thread_->message_loop()->task_runner();
 
   rasterizer_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RasterizerDelegate::CreateRasterizer,
                  base::Unretained(rasterizer_delegate_.get()),
-                 base::Passed(context_provider.PassInterfaceHandle()),
-                 scheduler_, base::MessageLoop::current()->task_runner(),
-                 error_callback));
+                 base::Passed(std::move(context_provider)), scheduler_,
+                 base::MessageLoop::current()->task_runner(), error_callback));
 }
 
 GpuOutput::~GpuOutput() {
   // Ensure destruction happens on the correct thread.
   rasterizer_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Drop<RasterizerDelegate>,
                             base::Passed(&rasterizer_delegate_)));
 }
 
 Scheduler* GpuOutput::GetScheduler() {
@@ skipping 43 matching lines @@
       scheduler, task_runner, error_callback));
 }
 
 void GpuOutput::RasterizerDelegate::SubmitNextFrame() {
   std::shared_ptr<RenderFrame> frame(frame_queue_->TakeFrame());
   DCHECK(frame);
   rasterizer_->SubmitFrame(frame);
 }
 
 }  // namespace compositor