Make shared memory allocation possible for all child process types.

content/common/child_process_host.cc

 // Copyright (c) 2011 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/child_process_host.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
+#include "base/process_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "content/common/child_process_info.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_logging.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #endif  // OS_LINUX
@@ skipping 235 matching lines @@
 }
 
 // static
 void ChildProcessHost::ReleaseCachedFonts(int pid) {
   // Release cached fonts that requested from a pid by decrementing the ref
   // count.  When ref count is zero, the handles are released.
   ChildProcessHost::FontCache::GetInstance()->ReleaseCachedFonts(pid);
 }
 #endif  // OS_WIN
 
+void ChildProcessHost::ForceShutdown() {
+  Send(new ChildProcessMsg_Shutdown());
+}
 
 bool ChildProcessHost::CreateChannel() {
   channel_id_ = ChildProcessInfo::GenerateRandomChannelID(this);
   channel_.reset(new IPC::Channel(
       channel_id_, IPC::Channel::MODE_SERVER, &listener_));
   if (!channel_->Connect())
     return false;
 
   for (size_t i = 0; i < filters_.size(); ++i)
     filters_[i]->OnFilterAdded(channel_.get());
@@ skipping 26 matching lines @@
 }
 
 bool ChildProcessHost::Send(IPC::Message* message) {
   if (!channel_.get()) {
     delete message;
     return false;
   }
   return channel_->Send(message);
 }
 
+void ChildProcessHost::OnAllocateSharedMemory(
+      uint32 buffer_size, base::ProcessHandle child_process_handle,
+      base::SharedMemoryHandle* shared_memory_handle) {
+  base::SharedMemory shared_buf;
+  if (!shared_buf.CreateAndMapAnonymous(buffer_size)) {
+    *shared_memory_handle = base::SharedMemory::NULLHandle();
+    NOTREACHED() << "Cannot map shared memory buffer";
+    return;
+  }
+  shared_buf.GiveToProcess(child_process_handle, shared_memory_handle);
+}
+
 void ChildProcessHost::OnChildDied() {
   delete this;
 }
 
 void ChildProcessHost::OnChildDisconnected() {
   OnChildDied();
 }
 
 void ChildProcessHost::ShutdownStarted() {
 }
 
 void ChildProcessHost::Notify(int type) {
 }
 
 ChildProcessHost::ListenerHook::ListenerHook(ChildProcessHost* host)
-    : host_(host) {
+    : host_(host), peer_handle_(base::kNullProcessHandle) {
+}
+
+ChildProcessHost::ListenerHook::~ListenerHook() {
+  base::CloseProcessHandle(peer_handle_);
 }
 
 void ChildProcessHost::ListenerHook::Shutdown() {
   host_ = NULL;
 }
 
 bool ChildProcessHost::ListenerHook::OnMessageReceived(
     const IPC::Message& msg) {
   if (!host_)
     return true;
@@ skipping 10 matching lines @@
 #endif
 
   bool handled = false;
   for (size_t i = 0; i < host_->filters_.size(); ++i) {
     if (host_->filters_[i]->OnMessageReceived(msg)) {
       handled = true;
       break;
     }
   }
 
-  if (!handled && msg.type() == ChildProcessHostMsg_ShutdownRequest::ID) {
-    if (host_->CanShutdown())
-      host_->Send(new ChildProcessMsg_Shutdown());
+  if (!handled) {
+    bool msg_is_good = false;
     handled = true;
+    IPC_BEGIN_MESSAGE_MAP_EX(ListenerHook, msg, msg_is_good)
+      IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ShutdownRequest,
+                          OnShutdownRequest)
+      IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateSharedMemory,
+                          OnAllocateSharedMemory)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP_EX()
+
+    if (!handled)
+      handled = host_->OnMessageReceived(msg);
   }
 
-  if (!handled)
-    handled = host_->OnMessageReceived(msg);
-
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (logger->Enabled())
     logger->OnPostDispatchMessage(msg, host_->channel_id_);
 #endif
   return handled;
 }
 
 void ChildProcessHost::ListenerHook::OnChannelConnected(int32 peer_pid) {
   if (!host_)
     return;
+  if (!base::OpenProcessHandle(peer_pid, &peer_handle_)) {
+    NOTREACHED();
+  }
   host_->opening_channel_ = false;
   host_->OnChannelConnected(peer_pid);
   // Notify in the main loop of the connection.
   host_->Notify(content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED);
 
   for (size_t i = 0; i < host_->filters_.size(); ++i)
     host_->filters_[i]->OnChannelConnected(peer_pid);
 }
 
 void ChildProcessHost::ListenerHook::OnChannelError() {
   if (!host_)
     return;
   host_->opening_channel_ = false;
   host_->OnChannelError();
 
   for (size_t i = 0; i < host_->filters_.size(); ++i)
     host_->filters_[i]->OnChannelError();
 
   // This will delete host_, which will also destroy this!
   host_->OnChildDisconnected();
 }
 
-void ChildProcessHost::ForceShutdown() {
-  Send(new ChildProcessMsg_Shutdown());
+bool ChildProcessHost::ListenerHook::Send(IPC::Message* message) {
+  return host_->Send(message);
 }
+
+void ChildProcessHost::ListenerHook::OnAllocateSharedMemory(
+    uint32 buffer_size,
+    base::SharedMemoryHandle* handle) {
+  ChildProcessHost::OnAllocateSharedMemory(
+      buffer_size, peer_handle_, handle);
+}
+
+void ChildProcessHost::ListenerHook::OnShutdownRequest() {
+  if (host_->CanShutdown())
+    host_->Send(new ChildProcessMsg_Shutdown());
+}