GPUChannel pools mailbox names.

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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 53 matching lines @@
 }
 
 void GpuChannelHost::SetStateLost() {
   state_ = kLost;
 }
 
 const GPUInfo& GpuChannelHost::gpu_info() const {
   return gpu_info_;
 }
 
+void GpuChannelHost::OnMessageReceived(const IPC::Message& message) {
+    bool handled = true;
+
+    IPC_BEGIN_MESSAGE_MAP(GpuChannelHost, message)
+      IPC_MESSAGE_HANDLER(GpuChannelMsg_GenerateMailboxNamesReply,
+                          OnGenerateMailboxNamesReply)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+
+    DCHECK(handled);
+}
+
 void GpuChannelHost::OnChannelError() {
   state_ = kLost;
 
   // Channel is invalid and will be reinitialized if this host is requested
   // again.
   channel_.reset();
 }
 
 bool GpuChannelHost::Send(IPC::Message* message) {
   // The GPU process never sends synchronous IPCs so clear the unblock flag to
@@ skipping 155 matching lines @@
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   io_loop->PostTask(FROM_HERE,
                     base::Bind(&GpuChannelHost::MessageFilter::RemoveRoute,
                                channel_filter_.get(), route_id));
 }
 
 bool GpuChannelHost::GenerateMailboxNames(unsigned num,
                                           std::vector<std::string>* names) {
   TRACE_EVENT0("gpu", "GenerateMailboxName");
   AutoLock lock(context_lock_);
-  return Send(new GpuChannelMsg_GenerateMailboxNames(num, names));
+
+  if (num > mailbox_name_pool_.size()) {
+    if (!Send(new GpuChannelMsg_GenerateMailboxNames(num, names)))
+      return false;
+  } else {
+    names->insert(names->begin(),
+                  mailbox_name_pool_.end() - num,
+                  mailbox_name_pool_.end());
+    mailbox_name_pool_.erase(mailbox_name_pool_.end() - num,
+                             mailbox_name_pool_.end());
+  }
+
+  const unsigned ideal_mailbox_pool_size = 100;
+  if (mailbox_name_pool_.size() < ideal_mailbox_pool_size / 2) {
+    Send(new GpuChannelMsg_GenerateMailboxNamesAsync(
+        ideal_mailbox_pool_size - mailbox_name_pool_.size()));
+  }
+
+  return true;
+}
+
+void GpuChannelHost::OnGenerateMailboxNamesReply(
+    const std::vector<std::string>& names) {
+  TRACE_EVENT0("gpu", "OnGenerateMailboxNamesReply");
+  AutoLock lock(context_lock_);
+
+  mailbox_name_pool_.insert(mailbox_name_pool_.end(),
+                            names.begin(),
+                            names.end());
 }
 
 GpuChannelHost::~GpuChannelHost() {}
 
 
 GpuChannelHost::MessageFilter::MessageFilter(GpuChannelHost* parent)
     : parent_(parent) {
 }
 
 GpuChannelHost::MessageFilter::~MessageFilter() {}
@@ skipping 13 matching lines @@
 void GpuChannelHost::MessageFilter::RemoveRoute(int route_id) {
   DCHECK(parent_->factory_->IsIOThread());
   ListenerMap::iterator it = listeners_.find(route_id);
   if (it != listeners_.end())
     listeners_.erase(it);
 }
 
 bool GpuChannelHost::MessageFilter::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(parent_->factory_->IsIOThread());
+
   // Never handle sync message replies or we will deadlock here.
   if (message.is_reply())
     return false;
 
-  DCHECK(message.routing_id() != MSG_ROUTING_CONTROL);
+  if (message.routing_id() == MSG_ROUTING_CONTROL) {
+    MessageLoop* main_loop = parent_->factory_->GetMainLoop();
+    main_loop->PostTask(FROM_HERE,
+                        base::Bind(&GpuChannelHost::OnMessageReceived,
+                                   parent_,
+                                   message));
+    return true;
+  }
 
   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,
@@ skipping 20 matching lines @@
     const GpuListenerInfo& info = it->second;
     info.loop->PostTask(
         FROM_HERE,
         base::Bind(&IPC::Listener::OnChannelError, info.listener));
   }
 
   listeners_.clear();
 }
 
 }  // namespace content