gpu: Use mojom API for creating gpu channel.

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2012 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 "content/browser/gpu/gpu_process_host.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 407 matching lines @@
 void GpuProcessHost::SendOnIO(GpuProcessKind kind,
                               bool force_create,
                               IPC::Message* message) {
   if (!BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&SendGpuProcessMessage, kind, force_create, message))) {
     delete message;
   }
 }
 
-GpuProcessHost::EstablishChannelRequest::EstablishChannelRequest()
-    : client_id(0) {}
-
-GpuProcessHost::EstablishChannelRequest::EstablishChannelRequest(
-    const EstablishChannelRequest& other) = default;
-
-GpuProcessHost::EstablishChannelRequest::~EstablishChannelRequest() {}
-
 service_manager::InterfaceProvider* GpuProcessHost::GetRemoteInterfaces() {
   return process_->child_connection()->GetRemoteInterfaces();
 }
 
 // static
 GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (int i = 0; i < GPU_PROCESS_KIND_COUNT; ++i) {
     GpuProcessHost* host = g_gpu_process_hosts[i];
     if (host && host->host_id_ == host_id && ValidateHost(host))
       return host;
   }
 
   return NULL;
 }
 
 GpuProcessHost::GpuProcessHost(int host_id, GpuProcessKind kind)
     : host_id_(host_id),
       valid_(true),
       in_process_(false),
       swiftshader_rendering_(false),
       kind_(kind),
       process_launched_(false),
       initialized_(false),
-      gpu_host_binding_(this) {
+      gpu_host_binding_(this),
+      weak_ptr_factory_(this) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSingleProcess) ||
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kInProcessGPU)) {
     in_process_ = true;
   }
 
   // If the 'single GPU process' policy ever changes, we still want to maintain
   // it for 'gpu thread' mode and only create one instance of host and thread.
   DCHECK(!in_process_ || g_gpu_process_hosts[kind] == NULL);
@@ skipping 188 matching lines @@
 
 void GpuProcessHost::AddFilter(IPC::MessageFilter* filter) {
   DCHECK(CalledOnValidThread());
   process_->GetHost()->AddFilter(filter);
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_Initialized, OnInitialized)
-    IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GpuMemoryBufferCreated,
                         OnGpuMemoryBufferCreated)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyingVideoSurfaceAck,
                         OnDestroyingVideoSurfaceAck)
 #endif
     IPC_MESSAGE_HANDLER(GpuHostMsg_FieldTrialActivated, OnFieldTrialActivated);
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 
@@ skipping 19 matching lines @@
   DCHECK(CalledOnValidThread());
   TRACE_EVENT0("gpu", "GpuProcessHost::EstablishGpuChannel");
 
   // If GPU features are already blacklisted, no need to establish the channel.
   if (!GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(NULL)) {
     DVLOG(1) << "GPU blacklisted, refusing to open a GPU channel.";
     callback.Run(IPC::ChannelHandle(), gpu::GPUInfo());
     return;
   }
 
-  EstablishChannelParams params;
-  params.client_id = client_id;
-  params.client_tracing_id = client_tracing_id;
-  params.preempts = preempts;
-  params.allow_view_command_buffers = allow_view_command_buffers;
-  params.allow_real_time_streams = allow_real_time_streams;
-  if (Send(new GpuMsg_EstablishChannel(params))) {
-    EstablishChannelRequest request;
-    request.client_id = client_id;
-    request.callback = callback;
-    channel_requests_.push(request);
-  } else {
-    DVLOG(1) << "Failed to send GpuMsg_EstablishChannel.";

[Fady Samuel, 2017/02/13 15:52:27]

What happens if the MessagePipe has a connection error?

[sadrul, 2017/02/13 15:57:23]

That would be when the gpu process has crashed or dying. GpuProcessHost itself
is destroyed in that case, and triggers the callbacks stored in
|channel_requests_| (in SendOutstandingReplies()).

-    callback.Run(IPC::ChannelHandle(), gpu::GPUInfo());
-  }
+  DCHECK_EQ(preempts, allow_view_command_buffers);
+  DCHECK_EQ(preempts, allow_real_time_streams);
+  bool is_gpu_host = preempts;
+
+  channel_requests_.push(callback);
+  gpu_service_ptr_->EstablishGpuChannel(
+      client_id, client_tracing_id, is_gpu_host,
+      base::Bind(&GpuProcessHost::OnChannelEstablished,
+                 weak_ptr_factory_.GetWeakPtr(), client_id, callback));
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableGpuShaderDiskCache)) {
     CreateChannelCache(client_id);
   }
 }
 
 void GpuProcessHost::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
@@ skipping 54 matching lines @@
 
   if (!initialized_) {
     GpuDataManagerImpl::GetInstance()->OnGpuProcessInitFailure();
     return;
   }
   GpuDataManagerImpl::GetInstance()->UpdateGpuInfo(gpu_info);
   GpuDataManagerImpl::GetInstance()->UpdateGpuFeatureInfo(gpu_feature_info);
 }
 
 void GpuProcessHost::OnChannelEstablished(
-    const IPC::ChannelHandle& channel_handle) {
+    int client_id,
+    const EstablishChannelCallback& callback,
+    mojo::ScopedMessagePipeHandle channel_handle) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnChannelEstablished");
-
-  if (channel_requests_.empty()) {
-    // This happens when GPU process is compromised.
-    RouteOnUIThread(GpuHostMsg_OnLogMessage(
-        logging::LOG_WARNING, "WARNING",
-        "Received a ChannelEstablished message but no requests in queue."));
-    return;
-  }
-  EstablishChannelRequest request = channel_requests_.front();
+  DCHECK(!channel_requests_.empty());
+  DCHECK(channel_requests_.front().Equals(callback));
   channel_requests_.pop();
 
   // Currently if any of the GPU features are blacklisted, we don't establish a
   // GPU channel.
-  if (channel_handle.mojo_handle.is_valid() &&
-      !GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(NULL)) {
-    Send(new GpuMsg_CloseChannel(request.client_id));
-    request.callback.Run(IPC::ChannelHandle(), gpu::GPUInfo());
+  if (channel_handle.is_valid() &&
+      !GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(nullptr)) {
+    Send(new GpuMsg_CloseChannel(client_id));
+    callback.Run(IPC::ChannelHandle(), gpu::GPUInfo());
     RouteOnUIThread(
         GpuHostMsg_OnLogMessage(logging::LOG_WARNING, "WARNING",
                                 "Hardware acceleration is unavailable."));
     return;
   }
 
-  request.callback.Run(channel_handle, gpu_info_);
+  callback.Run(IPC::ChannelHandle(channel_handle.release()), gpu_info_);
 }
 
 void GpuProcessHost::OnGpuMemoryBufferCreated(
     const gfx::GpuMemoryBufferHandle& handle) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnGpuMemoryBufferCreated");
 
   if (create_gpu_memory_buffer_requests_.empty())
     return;
 
   CreateGpuMemoryBufferCallback callback =
@@ skipping 234 matching lines @@
   process_->Launch(std::move(delegate), std::move(cmd_line), true);
   process_launched_ = true;
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             LAUNCHED, GPU_PROCESS_LIFETIME_EVENT_MAX);
   return true;
 }
 
 void GpuProcessHost::SendOutstandingReplies() {
   valid_ = false;
+
   // First send empty channel handles for all EstablishChannel requests.
   while (!channel_requests_.empty()) {
-    EstablishChannelRequest request = channel_requests_.front();
+    auto callback = channel_requests_.front();
     channel_requests_.pop();
-    request.callback.Run(IPC::ChannelHandle(), gpu::GPUInfo());
+    callback.Run(IPC::ChannelHandle(), gpu::GPUInfo());
   }
 
   while (!create_gpu_memory_buffer_requests_.empty()) {
     CreateGpuMemoryBufferCallback callback =
         create_gpu_memory_buffer_requests_.front();
     create_gpu_memory_buffer_requests_.pop();
     callback.Run(gfx::GpuMemoryBufferHandle());
   }
 
   if (!send_destroying_video_surface_done_cb_.is_null())
@@ skipping 109 matching lines @@
       GetShaderCacheFactorySingleton()->Get(client_id);
   if (!cache.get())
     return;
 
   cache->set_shader_loaded_callback(base::Bind(&HostLoadedShader, host_id_));
 
   client_id_to_shader_cache_[client_id] = cache;
 }
 
 }  // namespace content