gpu: Generate mailboxes on client side

content/common/gpu/client/gpu_channel_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/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/client/gpu_video_encode_accelerator_host.h"
 #include "content/common/gpu/gpu_messages.h"
-#include "gpu/command_buffer/common/mailbox.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "content/public/common/sandbox_init.h"
 #endif
 
 using base::AutoLock;
 using base::MessageLoopProxy;
 
@@ skipping 226 matching lines @@
   return target_handle;
 #else
   int duped_handle = HANDLE_EINTR(dup(source_handle.fd));
   if (duped_handle < 0)
     return base::SharedMemory::NULLHandle();
 
   return base::FileDescriptor(duped_handle, true);
 #endif
 }
 
-bool GpuChannelHost::GenerateMailboxNames(unsigned num,
-                                          std::vector<gpu::Mailbox>* names) {
-  DCHECK(names->empty());
-  TRACE_EVENT0("gpu", "GenerateMailboxName");
-  size_t generate_count = channel_filter_->GetMailboxNames(num, names);
-
-  if (names->size() < num) {
-    std::vector<gpu::Mailbox> new_names;
-    if (!Send(new GpuChannelMsg_GenerateMailboxNames(num - names->size(),
-                                                     &new_names)))
-      return false;
-    names->insert(names->end(), new_names.begin(), new_names.end());
-  }
-
-  if (generate_count > 0)
-    Send(new GpuChannelMsg_GenerateMailboxNamesAsync(generate_count));
-
-  return true;
-}
-
 int32 GpuChannelHost::ReserveTransferBufferId() {
   return next_transfer_buffer_id_.GetNext();
 }
 
 gfx::GpuMemoryBufferHandle GpuChannelHost::ShareGpuMemoryBufferToGpuProcess(
     gfx::GpuMemoryBufferHandle source_handle) {
   switch (source_handle.type) {
     case gfx::SHARED_MEMORY_BUFFER: {
       gfx::GpuMemoryBufferHandle handle;
       handle.type = gfx::SHARED_MEMORY_BUFFER;
@@ skipping 15 matching lines @@
 }
 
 GpuChannelHost::~GpuChannelHost() {
   // channel_ must be destroyed on the main thread.
   if (!factory_->IsMainThread())
     factory_->GetMainLoop()->DeleteSoon(FROM_HERE, channel_.release());
 }
 
 
 GpuChannelHost::MessageFilter::MessageFilter()
-    : lost_(false),
-      requested_mailboxes_(0) {
+    : lost_(false) {
 }
 
 GpuChannelHost::MessageFilter::~MessageFilter() {}
 
 void GpuChannelHost::MessageFilter::AddRoute(
     int route_id,
     base::WeakPtr<IPC::Listener> listener,
     scoped_refptr<MessageLoopProxy> loop) {
   DCHECK(listeners_.find(route_id) == listeners_.end());
   GpuListenerInfo info;
   info.listener = listener;
   info.loop = loop;
   listeners_[route_id] = info;
 }
 
 void GpuChannelHost::MessageFilter::RemoveRoute(int route_id) {
   ListenerMap::iterator it = listeners_.find(route_id);
   if (it != listeners_.end())
     listeners_.erase(it);
 }
 
 bool GpuChannelHost::MessageFilter::OnMessageReceived(
     const IPC::Message& message) {
   // Never handle sync message replies or we will deadlock here.
   if (message.is_reply())
     return false;
 
-  if (message.routing_id() == MSG_ROUTING_CONTROL)
-    return OnControlMessageReceived(message);
+  ListenerMap::iterator it = listeners_.find(message.routing_id());
+  if (it == listeners_.end())
+    return false;
 
-  ListenerMap::iterator it = listeners_.find(message.routing_id());
-
-  if (it != listeners_.end()) {
-    const GpuListenerInfo& info = it->second;
-    info.loop->PostTask(
-        FROM_HERE,
-        base::Bind(
-            base::IgnoreResult(&IPC::Listener::OnMessageReceived),
-            info.listener,
-            message));
-  }
-
+  const GpuListenerInfo& info = it->second;
+  info.loop->PostTask(
+      FROM_HERE,
+      base::Bind(
+          base::IgnoreResult(&IPC::Listener::OnMessageReceived),
+          info.listener,
+          message));
   return true;
 }
 
 void GpuChannelHost::MessageFilter::OnChannelError() {
   // Set the lost state before signalling the proxies. That way, if they
   // themselves post a task to recreate the context, they will not try to re-use
   // this channel host.
   {
     AutoLock lock(lock_);
     lost_ = true;
@@ skipping 11 matching lines @@
   }
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
-size_t GpuChannelHost::MessageFilter::GetMailboxNames(
-    size_t num, std::vector<gpu::Mailbox>* names) {
-  AutoLock lock(lock_);
-  size_t count = std::min(num, mailbox_name_pool_.size());
-  names->insert(names->begin(),
-                mailbox_name_pool_.end() - count,
-                mailbox_name_pool_.end());
-  mailbox_name_pool_.erase(mailbox_name_pool_.end() - count,
-                           mailbox_name_pool_.end());
-
-  const size_t ideal_mailbox_pool_size = 100;
-  size_t total = mailbox_name_pool_.size() + requested_mailboxes_;
-  DCHECK_LE(total, ideal_mailbox_pool_size);
-  if (total >= ideal_mailbox_pool_size / 2)
-    return 0;
-  size_t request = ideal_mailbox_pool_size - total;
-  requested_mailboxes_ += request;
-  return request;
-}
-
-bool GpuChannelHost::MessageFilter::OnControlMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-
-  IPC_BEGIN_MESSAGE_MAP(GpuChannelHost::MessageFilter, message)
-  IPC_MESSAGE_HANDLER(GpuChannelMsg_GenerateMailboxNamesReply,
-                      OnGenerateMailboxNamesReply)
-  IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  DCHECK(handled);
-  return handled;
-}
-
-void GpuChannelHost::MessageFilter::OnGenerateMailboxNamesReply(
-    const std::vector<gpu::Mailbox>& names) {
-  TRACE_EVENT0("gpu", "OnGenerateMailboxNamesReply");
-  AutoLock lock(lock_);
-  DCHECK_LE(names.size(), requested_mailboxes_);
-  requested_mailboxes_ -= names.size();
-  mailbox_name_pool_.insert(mailbox_name_pool_.end(),
-                            names.begin(),
-                            names.end());
-}
-
-
 }  // namespace content