mus::GpuService: Support establish GpuChannel asynchronously.

components/mus/common/gpu_service.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 "components/mus/common/gpu_service.h"
 
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
+#include "base/threading/thread_restrictions.h"
 #include "components/mus/common/gpu_type_converters.h"
-#include "components/mus/common/mojo_gpu_memory_buffer_manager.h"
 #include "components/mus/common/switches.h"
 #include "components/mus/public/interfaces/gpu_service.mojom.h"
-#include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "services/shell/public/cpp/connector.h"
 
 namespace mus {
 
-GpuService::GpuService()
+namespace {
+
+void PostTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
+              const tracked_objects::Location& from_here,
+              const base::Closure& callback) {
+  runner->PostTask(from_here, callback);
+}
+
+GpuService* g_gpu_service = nullptr;
+}
+
+GpuService::GpuService(shell::Connector* connector)
     : main_message_loop_(base::MessageLoop::current()),
+      connector_(connector),
       shutdown_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                       base::WaitableEvent::InitialState::NOT_SIGNALED),
       io_thread_("GPUIOThread"),
-      gpu_memory_buffer_manager_(new MojoGpuMemoryBufferManager) {
+      gpu_memory_buffer_manager_(new MojoGpuMemoryBufferManager),
+      is_establishing_(false),
+      establishing_condition_(&lock_) {
+  DCHECK(main_message_loop_);
+  DCHECK(connector_);
   base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
   thread_options.priority = base::ThreadPriority::NORMAL;
   CHECK(io_thread_.StartWithOptions(thread_options));
 }
 
 GpuService::~GpuService() {}
 
 // static
 bool GpuService::UseChromeGpuCommandBuffer() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseChromeGpuCommandBufferInMus);
 }
 
 // static
+void GpuService::Initialize(shell::Connector* connector) {
+  DCHECK(!g_gpu_service);
+  g_gpu_service = new GpuService(connector);
+}
+
+// static
 GpuService* GpuService::GetInstance() {
-  return base::Singleton<GpuService,
-                         base::LeakySingletonTraits<GpuService>>::get();
+  DCHECK(g_gpu_service);
+  return g_gpu_service;
 }
 
-scoped_refptr<gpu::GpuChannelHost> GpuService::EstablishGpuChannel(
-    shell::Connector* connector) {
+void GpuService::EstablishGpuChannel(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
+  auto runner = base::ThreadTaskRunnerHandle::Get();
+  if (GetGpuChannelLocked()) {
+    runner->PostTask(FROM_HERE, callback);
+    return;
+  }
+  base::Closure wrapper_callback =
+      IsMainThread() ? callback
+                     : base::Bind(PostTask, runner, FROM_HERE, callback);
+  establish_callbacks_.push_back(wrapper_callback);
+
+  if (!is_establishing_) {
+    is_establishing_ = true;
+    main_message_loop_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&GpuService::EstablishGpuChannelOnMainThread,
+                              base::Unretained(this)));
+  }
+}
+
+scoped_refptr<gpu::GpuChannelHost> GpuService::EstablishGpuChannelSync() {
+  base::AutoLock auto_lock(lock_);
+  if (GetGpuChannelLocked())
+    return gpu_channel_;
+
+  if (!IsMainThread()) {
+    if (!is_establishing_) {
+      // Create an establishing gpu channel task, if there isn't one.
+      is_establishing_ = true;
+      main_message_loop_->task_runner()->PostTask(
+          FROM_HERE, base::Bind(&GpuService::EstablishGpuChannelOnMainThread,
+                                base::Unretained(this)));
+    }
+    // Wait until the pending establishing task is finished.
+    base::ThreadRestrictions::ScopedAllowWait allow_wait;
+    do {
+      establishing_condition_.Wait();
+    } while (is_establishing_);
+    return gpu_channel_;
+  }
+
+  if (!gpu_service_) {
+    // gpu_service_ is null, it means there is no unfinished async
+    // EstablishGpuChannel call, so we should issue one.
+    is_establishing_ = true;
+    EstablishGpuChannelOnMainThreadLocked();
+  }
+
+  base::AutoUnlock auto_unlock(lock_);
+  base::ThreadRestrictions::ScopedAllowWait allow_wait;

[jam, 2016/06/23 16:39:39]

why isn't this a mojo::SyncCallRestrictions::ScopedAllowSyncCall
allow_sync_call; and calling the sync GPU Service method instead of the async
one?

[jam, 2016/06/23 16:42:58]

This is undoing Yuzhu's change from yesterday that switched to sync calls
(https://codereview.chromium.org/2084993002/diff/40001/components/mus/common/g...).
see linked bug (we are removing WaitForIncomingResponse calls)

[Peng, 2016/06/23 17:07:36]

Becasue maybe there is unfinished pending async method call, so we have to use
WaitForIncomingResponse() for that case. To make code simpler, if no pending
async method call, we just use async method call too.

If no WaitForIncomingResponse, probably we have to use RunLoop to start a nest
loop. But RunLoop is not recommended. :(

+  if (!gpu_service_.WaitForIncomingResponse()) {
+    DLOG(WARNING)
+        << "Channel encountered error while establishing gpu channel.";
+    return nullptr;
+  }
+  return gpu_channel_;
+}
+
+scoped_refptr<gpu::GpuChannelHost> GpuService::GetGpuChannel() {
+  base::AutoLock auto_lock(lock_);
+  return GetGpuChannelLocked();
+}
+
+scoped_refptr<gpu::GpuChannelHost> GpuService::GetGpuChannelLocked() {
   if (gpu_channel_ && gpu_channel_->IsLost()) {
-    gpu_channel_->DestroyChannel();
+    main_message_loop_->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&gpu::GpuChannelHost::DestroyChannel, gpu_channel_));
     gpu_channel_ = nullptr;
   }
+  return gpu_channel_;
+}
 
-  if (gpu_channel_)
-    return gpu_channel_;
+void GpuService::EstablishGpuChannelOnMainThread() {
+  base::AutoLock auto_lock(lock_);
+  DCHECK(IsMainThread());
+  EstablishGpuChannelOnMainThreadLocked();
+}
 
-  mus::mojom::GpuServicePtr gpu_service;
-  connector->ConnectToInterface("mojo:mus", &gpu_service);
+void GpuService::EstablishGpuChannelOnMainThreadLocked() {
+  DCHECK(IsMainThread());
+  // is_establishing_ is false, it means GpuService::EstablishGpuChannelSync()
+  // has been used, and we don't need try to establish a new GPU channel
+  // anymore.
+  if (!is_establishing_)
+    return;
+  connector_->ConnectToInterface("mojo:mus", &gpu_service_);
+  gpu_service_->EstablishGpuChannel(
+      base::Bind(&GpuService::EstablishGpuChannelOnMainThreadDone,
+                 base::Unretained(this)));
+}
 
-  int client_id = 0;
-  mojom::ChannelHandlePtr channel_handle;
-  mojom::GpuInfoPtr gpu_info;
-  {
-    // TODO(penghuang): Remove the ScopedAllowSyncCall when HW rendering is
-    // enabled in mus chrome.
-    mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
-    if (!gpu_service->EstablishGpuChannel(&client_id, &channel_handle,
-                                          &gpu_info)) {
-      DLOG(WARNING)
-          << "Channel encountered error while establishing gpu channel.";
-      return nullptr;
-    }
+void GpuService::EstablishGpuChannelOnMainThreadDone(
+    int client_id,
+    mojom::ChannelHandlePtr channel_handle,
+    mojom::GpuInfoPtr gpu_info) {
+  DCHECK(IsMainThread());
+  scoped_refptr<gpu::GpuChannelHost> gpu_channel;
+  if (client_id) {
+    // TODO(penghuang): Get the real gpu info from mus.
+    gpu_channel = gpu::GpuChannelHost::Create(
+        this, client_id, gpu::GPUInfo(),
+        channel_handle.To<IPC::ChannelHandle>(), &shutdown_event_,
+        gpu_memory_buffer_manager_.get());
   }
 
-  // TODO(penghuang): Get the real gpu info from mus.
-  gpu_channel_ = gpu::GpuChannelHost::Create(
-      this, client_id, gpu::GPUInfo(), channel_handle.To<IPC::ChannelHandle>(),
-      &shutdown_event_, gpu_memory_buffer_manager_.get());
-  return gpu_channel_;
+  base::AutoLock auto_lock(lock_);
+  DCHECK(is_establishing_);
+  DCHECK(!gpu_channel_);
+
+  is_establishing_ = false;
+  gpu_channel_ = gpu_channel;
+  establishing_condition_.Broadcast();
+
+  for (const auto& i : establish_callbacks_)
+    i.Run();
+  establish_callbacks_.clear();
+  gpu_service_.reset();
 }
 
 bool GpuService::IsMainThread() {
   return base::MessageLoop::current() == main_message_loop_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 GpuService::GetIOThreadTaskRunner() {
   return io_thread_.task_runner();
 }
@@ skipping 11 matching lines @@
   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 mus