mus-gpu: Fix handling channel establish requests.

services/ui/public/cpp/gpu/gpu.cc

 // Copyright 2016 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/ui/public/cpp/gpu/gpu.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
@@ skipping 77 matching lines @@
       gpu::kNullSurfaceHandle, GURL("chrome://gpu/MusContextFactory"),
       automatic_flushes, support_locking, gpu::SharedMemoryLimits(), attributes,
       shared_context_provider, ui::command_buffer_metrics::MUS_CLIENT_CONTEXT));
 }
 
 void Gpu::EstablishGpuChannel(
     const gpu::GpuChannelEstablishedCallback& callback) {
   DCHECK(IsMainThread());
   scoped_refptr<gpu::GpuChannelHost> channel = GetGpuChannel();
   if (channel) {
-    main_task_runner_->PostTask(FROM_HERE,
-                                base::Bind(callback, std::move(channel)));
+    callback.Run(std::move(channel));
     return;
   }
   establish_callbacks_.push_back(callback);
   if (gpu_)
     return;
 
   gpu_ = factory_.Run();
   gpu_->EstablishGpuChannel(
       base::Bind(&Gpu::OnEstablishedGpuChannel, base::Unretained(this)));
 }
@@ skipping 37 matching lines @@
   DCHECK(gpu_.get());
   DCHECK(!gpu_channel_);
 
   if (client_id && channel_handle.is_valid()) {
     gpu_channel_ = gpu::GpuChannelHost::Create(
         this, client_id, gpu_info, IPC::ChannelHandle(channel_handle.release()),
         &shutdown_event_, gpu_memory_buffer_manager_.get());
   }
 
   gpu_.reset();
-  for (const auto& i : establish_callbacks_)
-    i.Run(gpu_channel_);
+  auto callbacks = std::move(establish_callbacks_);
   establish_callbacks_.clear();
+  for (const auto& callback : callbacks)
+    callback.Run(gpu_channel_);
 }
 
 bool Gpu::IsMainThread() {
   return main_task_runner_->BelongsToCurrentThread();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> Gpu::GetIOThreadTaskRunner() {
   return io_task_runner_;
 }
 
 std::unique_ptr<base::SharedMemory> Gpu::AllocateSharedMemory(size_t size) {
   mojo::ScopedSharedBufferHandle handle =
       mojo::SharedBufferHandle::Create(size);
   if (!handle.is_valid())
     return nullptr;
 
   base::SharedMemoryHandle platform_handle;
   size_t shared_memory_size;
   bool readonly;
   MojoResult result = mojo::UnwrapSharedMemoryHandle(
       std::move(handle), &platform_handle, &shared_memory_size, &readonly);
   if (result != MOJO_RESULT_OK)
     return nullptr;
   DCHECK_EQ(shared_memory_size, size);
 
   return base::MakeUnique<base::SharedMemory>(platform_handle, readonly);
 }
 
 }  // namespace ui