content/common/gpu/client/gpu_channel_host.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/gpu/client/gpu_channel_host.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/debug/trace_event.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/message_loop/message_loop_proxy.h"
  13 #include "base/posix/eintr_wrapper.h"
  14 #include "base/threading/thread_restrictions.h"
  15 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
  16 #include "content/common/gpu/gpu_messages.h"
  17 #include "ipc/ipc_sync_message_filter.h"
  18 #include "url/gurl.h"
  19
  20 #if defined(OS_WIN)
  21 #include "content/public/common/sandbox_init.h"
  22 #endif
  23
  24 using base::AutoLock;
  25 using base::MessageLoopProxy;
  26
  27 namespace content {
  28
  29 GpuListenerInfo::GpuListenerInfo() {}
  30
  31 GpuListenerInfo::~GpuListenerInfo() {}
  32
  33 // static
  34 scoped_refptr<GpuChannelHost> GpuChannelHost::Create(
  35     GpuChannelHostFactory* factory,
  36     const gpu::GPUInfo& gpu_info,
  37     const IPC::ChannelHandle& channel_handle,
  38     base::WaitableEvent* shutdown_event) {
  39   DCHECK(factory->IsMainThread());
  40   scoped_refptr<GpuChannelHost> host = new GpuChannelHost(factory, gpu_info);
  41   host->Connect(channel_handle, shutdown_event);
  42   return host;
  43 }
  44
  45 // static
  46 bool GpuChannelHost::IsValidGpuMemoryBuffer(
  47     gfx::GpuMemoryBufferHandle handle) {
  48   switch (handle.type) {
  49     case gfx::SHARED_MEMORY_BUFFER:
  50 #if defined(OS_MACOSX)
  51     case gfx::IO_SURFACE_BUFFER:
  52 #endif
  53 #if defined(OS_ANDROID)
  54     case gfx::SURFACE_TEXTURE_BUFFER:
  55 #endif
  56 #if defined(USE_X11)
  57     case gfx::X11_PIXMAP_BUFFER:
  58 #endif
  59       return true;
  60     default:
  61       return false;
  62   }
  63 }
  64
  65 GpuChannelHost::GpuChannelHost(GpuChannelHostFactory* factory,
  66                                const gpu::GPUInfo& gpu_info)
  67     : factory_(factory),
  68       gpu_info_(gpu_info) {
  69   next_transfer_buffer_id_.GetNext();
  70   next_gpu_memory_buffer_id_.GetNext();
  71   next_route_id_.GetNext();
  72 }
  73
  74 void GpuChannelHost::Connect(const IPC::ChannelHandle& channel_handle,
  75                              base::WaitableEvent* shutdown_event) {
  76   // Open a channel to the GPU process. We pass NULL as the main listener here
  77   // since we need to filter everything to route it to the right thread.
  78   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
  79   channel_ = IPC::SyncChannel::Create(channel_handle,
  80                                       IPC::Channel::MODE_CLIENT,
  81                                       NULL,
  82                                       io_loop.get(),
  83                                       true,
  84                                       shutdown_event);
  85
  86   sync_filter_ = new IPC::SyncMessageFilter(shutdown_event);
  87
  88   channel_->AddFilter(sync_filter_.get());
  89
  90   channel_filter_ = new MessageFilter();
  91
  92   // Install the filter last, because we intercept all leftover
  93   // messages.
  94   channel_->AddFilter(channel_filter_.get());
  95 }
  96
  97 bool GpuChannelHost::Send(IPC::Message* msg) {
  98   // Callee takes ownership of message, regardless of whether Send is
  99   // successful. See IPC::Sender.
 100   scoped_ptr<IPC::Message> message(msg);
 101   // The GPU process never sends synchronous IPCs so clear the unblock flag to
 102   // preserve order.
 103   message->set_unblock(false);
 104
 105   // Currently we need to choose between two different mechanisms for sending.
 106   // On the main thread we use the regular channel Send() method, on another
 107   // thread we use SyncMessageFilter. We also have to be careful interpreting
 108   // IsMainThread() since it might return false during shutdown,
 109   // impl we are actually calling from the main thread (discard message then).
 110   //
 111   // TODO: Can we just always use sync_filter_ since we setup the channel
 112   //       without a main listener?
 113   if (factory_->IsMainThread()) {
 114     // http://crbug.com/125264
 115     base::ThreadRestrictions::ScopedAllowWait allow_wait;
 116     bool result = channel_->Send(message.release());
 117     if (!result)
 118       DVLOG(1) << "GpuChannelHost::Send failed: Channel::Send failed";
 119     return result;
 120   } else if (base::MessageLoop::current()) {
 121     bool result = sync_filter_->Send(message.release());
 122     if (!result)
 123       DVLOG(1) << "GpuChannelHost::Send failed: SyncMessageFilter::Send failed";
 124     return result;
 125   }
 126
 127   return false;
 128 }
 129
 130 CommandBufferProxyImpl* GpuChannelHost::CreateViewCommandBuffer(
 131     int32 surface_id,
 132     CommandBufferProxyImpl* share_group,
 133     const std::vector<int32>& attribs,
 134     const GURL& active_url,
 135     gfx::GpuPreference gpu_preference) {
 136   TRACE_EVENT1("gpu",
 137                "GpuChannelHost::CreateViewCommandBuffer",
 138                "surface_id",
 139                surface_id);
 140
 141   GPUCreateCommandBufferConfig init_params;
 142   init_params.share_group_id =
 143       share_group ? share_group->GetRouteID() : MSG_ROUTING_NONE;
 144   init_params.attribs = attribs;
 145   init_params.active_url = active_url;
 146   init_params.gpu_preference = gpu_preference;
 147   int32 route_id = GenerateRouteID();
 148   CreateCommandBufferResult result = factory_->CreateViewCommandBuffer(
 149       surface_id, init_params, route_id);
 150   if (result != CREATE_COMMAND_BUFFER_SUCCEEDED) {
 151     LOG(ERROR) << "GpuChannelHost::CreateViewCommandBuffer failed.";
 152
 153     if (result == CREATE_COMMAND_BUFFER_FAILED_AND_CHANNEL_LOST) {
 154       // The GPU channel needs to be considered lost. The caller will
 155       // then set up a new connection, and the GPU channel and any
 156       // view command buffers will all be associated with the same GPU
 157       // process.
 158       DCHECK(MessageLoopProxy::current().get());
 159
 160       scoped_refptr<base::MessageLoopProxy> io_loop =
 161           factory_->GetIOLoopProxy();
 162       io_loop->PostTask(
 163           FROM_HERE,
 164           base::Bind(&GpuChannelHost::MessageFilter::OnChannelError,
 165                      channel_filter_.get()));
 166     }
 167
 168     return NULL;
 169   }
 170
 171   CommandBufferProxyImpl* command_buffer =
 172       new CommandBufferProxyImpl(this, route_id);
 173   AddRoute(route_id, command_buffer->AsWeakPtr());
 174
 175   AutoLock lock(context_lock_);
 176   proxies_[route_id] = command_buffer;
 177   return command_buffer;
 178 }
 179
 180 CommandBufferProxyImpl* GpuChannelHost::CreateOffscreenCommandBuffer(
 181     const gfx::Size& size,
 182     CommandBufferProxyImpl* share_group,
 183     const std::vector<int32>& attribs,
 184     const GURL& active_url,
 185     gfx::GpuPreference gpu_preference) {
 186   TRACE_EVENT0("gpu", "GpuChannelHost::CreateOffscreenCommandBuffer");
 187
 188   GPUCreateCommandBufferConfig init_params;
 189   init_params.share_group_id =
 190       share_group ? share_group->GetRouteID() : MSG_ROUTING_NONE;
 191   init_params.attribs = attribs;
 192   init_params.active_url = active_url;
 193   init_params.gpu_preference = gpu_preference;
 194   int32 route_id = GenerateRouteID();
 195   bool succeeded = false;
 196   if (!Send(new GpuChannelMsg_CreateOffscreenCommandBuffer(size,
 197                                                            init_params,
 198                                                            route_id,
 199                                                            &succeeded))) {
 200     LOG(ERROR) << "Failed to send GpuChannelMsg_CreateOffscreenCommandBuffer.";
 201     return NULL;
 202   }
 203
 204   if (!succeeded) {
 205     LOG(ERROR)
 206         << "GpuChannelMsg_CreateOffscreenCommandBuffer returned failure.";
 207     return NULL;
 208   }
 209
 210   CommandBufferProxyImpl* command_buffer =
 211       new CommandBufferProxyImpl(this, route_id);
 212   AddRoute(route_id, command_buffer->AsWeakPtr());
 213
 214   AutoLock lock(context_lock_);
 215   proxies_[route_id] = command_buffer;
 216   return command_buffer;
 217 }
 218
 219 scoped_ptr<media::VideoDecodeAccelerator> GpuChannelHost::CreateVideoDecoder(
 220     int command_buffer_route_id) {
 221   TRACE_EVENT0("gpu", "GpuChannelHost::CreateVideoDecoder");
 222   AutoLock lock(context_lock_);
 223   ProxyMap::iterator it = proxies_.find(command_buffer_route_id);
 224   DCHECK(it != proxies_.end());
 225   return it->second->CreateVideoDecoder();
 226 }
 227
 228 scoped_ptr<media::VideoEncodeAccelerator> GpuChannelHost::CreateVideoEncoder(
 229     int command_buffer_route_id) {
 230   TRACE_EVENT0("gpu", "GpuChannelHost::CreateVideoEncoder");
 231   AutoLock lock(context_lock_);
 232   ProxyMap::iterator it = proxies_.find(command_buffer_route_id);
 233   DCHECK(it != proxies_.end());
 234   return it->second->CreateVideoEncoder();
 235 }
 236
 237 void GpuChannelHost::DestroyCommandBuffer(
 238     CommandBufferProxyImpl* command_buffer) {
 239   TRACE_EVENT0("gpu", "GpuChannelHost::DestroyCommandBuffer");
 240
 241   int route_id = command_buffer->GetRouteID();
 242   Send(new GpuChannelMsg_DestroyCommandBuffer(route_id));
 243   RemoveRoute(route_id);
 244
 245   AutoLock lock(context_lock_);
 246   proxies_.erase(route_id);
 247   delete command_buffer;
 248 }
 249
 250 void GpuChannelHost::AddRoute(
 251     int route_id, base::WeakPtr<IPC::Listener> listener) {
 252   DCHECK(MessageLoopProxy::current().get());
 253
 254   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
 255   io_loop->PostTask(FROM_HERE,
 256                     base::Bind(&GpuChannelHost::MessageFilter::AddRoute,
 257                                channel_filter_.get(), route_id, listener,
 258                                MessageLoopProxy::current()));
 259 }
 260
 261 void GpuChannelHost::RemoveRoute(int route_id) {
 262   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
 263   io_loop->PostTask(FROM_HERE,
 264                     base::Bind(&GpuChannelHost::MessageFilter::RemoveRoute,
 265                                channel_filter_.get(), route_id));
 266 }
 267
 268 base::SharedMemoryHandle GpuChannelHost::ShareToGpuProcess(
 269     base::SharedMemoryHandle source_handle) {
 270   if (IsLost())
 271     return base::SharedMemory::NULLHandle();
 272
 273 #if defined(OS_WIN)
 274   // Windows needs to explicitly duplicate the handle out to another process.
 275   base::SharedMemoryHandle target_handle;
 276   if (!BrokerDuplicateHandle(source_handle,
 277                              channel_->GetPeerPID(),
 278                              &target_handle,
 279                              FILE_GENERIC_READ | FILE_GENERIC_WRITE,
 280                              0)) {
 281     return base::SharedMemory::NULLHandle();
 282   }
 283
 284   return target_handle;
 285 #else
 286   int duped_handle = HANDLE_EINTR(dup(source_handle.fd));
 287   if (duped_handle < 0)
 288     return base::SharedMemory::NULLHandle();
 289
 290   return base::FileDescriptor(duped_handle, true);
 291 #endif
 292 }
 293
 294 int32 GpuChannelHost::ReserveTransferBufferId() {
 295   return next_transfer_buffer_id_.GetNext();
 296 }
 297
 298 gfx::GpuMemoryBufferHandle GpuChannelHost::ShareGpuMemoryBufferToGpuProcess(
 299     gfx::GpuMemoryBufferHandle source_handle) {
 300   switch (source_handle.type) {
 301     case gfx::SHARED_MEMORY_BUFFER: {
 302       gfx::GpuMemoryBufferHandle handle;
 303       handle.type = gfx::SHARED_MEMORY_BUFFER;
 304       handle.handle = ShareToGpuProcess(source_handle.handle);
 305       return handle;
 306     }
 307 #if defined(USE_OZONE)
 308     case gfx::OZONE_NATIVE_BUFFER:
 309       return source_handle;
 310 #endif
 311 #if defined(OS_MACOSX)
 312     case gfx::IO_SURFACE_BUFFER:
 313       return source_handle;
 314 #endif
 315 #if defined(OS_ANDROID)
 316     case gfx::SURFACE_TEXTURE_BUFFER:
 317       return source_handle;
 318 #endif
 319 #if defined(USE_X11)
 320     case gfx::X11_PIXMAP_BUFFER:
 321       return source_handle;
 322 #endif
 323     default:
 324       NOTREACHED();
 325       return gfx::GpuMemoryBufferHandle();
 326   }
 327 }
 328
 329 int32 GpuChannelHost::ReserveGpuMemoryBufferId() {
 330   return next_gpu_memory_buffer_id_.GetNext();
 331 }
 332
 333 int32 GpuChannelHost::GenerateRouteID() {
 334   return next_route_id_.GetNext();
 335 }
 336
 337 GpuChannelHost::~GpuChannelHost() {
 338   // channel_ must be destroyed on the main thread.
 339   if (!factory_->IsMainThread())
 340     factory_->GetMainLoop()->DeleteSoon(FROM_HERE, channel_.release());
 341 }
 342
 343
 344 GpuChannelHost::MessageFilter::MessageFilter()
 345     : lost_(false) {
 346 }
 347
 348 GpuChannelHost::MessageFilter::~MessageFilter() {}
 349
 350 void GpuChannelHost::MessageFilter::AddRoute(
 351     int route_id,
 352     base::WeakPtr<IPC::Listener> listener,
 353     scoped_refptr<MessageLoopProxy> loop) {
 354   DCHECK(listeners_.find(route_id) == listeners_.end());
 355   GpuListenerInfo info;
 356   info.listener = listener;
 357   info.loop = loop;
 358   listeners_[route_id] = info;
 359 }
 360
 361 void GpuChannelHost::MessageFilter::RemoveRoute(int route_id) {
 362   ListenerMap::iterator it = listeners_.find(route_id);
 363   if (it != listeners_.end())
 364     listeners_.erase(it);
 365 }
 366
 367 bool GpuChannelHost::MessageFilter::OnMessageReceived(
 368     const IPC::Message& message) {
 369   // Never handle sync message replies or we will deadlock here.
 370   if (message.is_reply())
 371     return false;
 372
 373   ListenerMap::iterator it = listeners_.find(message.routing_id());
 374   if (it == listeners_.end())
 375     return false;
 376
 377   const GpuListenerInfo& info = it->second;
 378   info.loop->PostTask(
 379       FROM_HERE,
 380       base::Bind(
 381           base::IgnoreResult(&IPC::Listener::OnMessageReceived),
 382           info.listener,
 383           message));
 384   return true;
 385 }
 386
 387 void GpuChannelHost::MessageFilter::OnChannelError() {
 388   // Set the lost state before signalling the proxies. That way, if they
 389   // themselves post a task to recreate the context, they will not try to re-use
 390   // this channel host.
 391   {
 392     AutoLock lock(lock_);
 393     lost_ = true;
 394   }
 395
 396   // Inform all the proxies that an error has occurred. This will be reported
 397   // via OpenGL as a lost context.
 398   for (ListenerMap::iterator it = listeners_.begin();
 399        it != listeners_.end();
 400        it++) {
 401     const GpuListenerInfo& info = it->second;
 402     info.loop->PostTask(
 403         FROM_HERE,
 404         base::Bind(&IPC::Listener::OnChannelError, info.listener));
 405   }
 406
 407   listeners_.clear();
 408 }
 409
 410 bool GpuChannelHost::MessageFilter::IsLost() const {
 411   AutoLock lock(lock_);
 412   return lost_;
 413 }
 414
 415 }  // namespace content