Renderer process can allocate anonymous shared memory without help from browser process on Windows.

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 701 matching lines @@
   // be treated as empty documents that can commit synchronously.
   WebString swappedout_scheme(ASCIIToUTF16(chrome::kSwappedOutScheme));
   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(swappedout_scheme);
   WebSecurityPolicy::registerURLSchemeAsEmptyDocument(swappedout_scheme);
 }
 
 void RenderThreadImpl::RecordUserMetrics(const std::string& action) {
   Send(new ViewHostMsg_UserMetricsRecordAction(action));
 }
 
-base::SharedMemoryHandle RenderThreadImpl::HostAllocateSharedMemoryBuffer(
-    uint32 buffer_size) {
-  base::SharedMemoryHandle mem_handle = base::SharedMemoryHandle();
-  Send(new ChildProcessHostMsg_SyncAllocateSharedMemory(
-                buffer_size, &mem_handle));
-  return mem_handle;
+scoped_ptr<base::SharedMemory>
+    RenderThreadImpl::HostAllocateSharedMemoryBuffer(uint32 size) {
+  //if (!size)
+  //  return scoped_ptr<base::SharedMemory>();
+
+//#if defined(OS_WIN)
+//  scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
+//  if (!shared_memory->CreateAnonymous(size))
+//    return scoped_ptr<base::SharedMemory>();
+//
+//  return scoped_ptr<base::SharedMemory>(shared_memory.release());
+//#else
+  base::SharedMemoryHandle handle;
+  bool success;
+  IPC::Message* message =
+      new ChildProcessHostMsg_SyncAllocateSharedMemory(size, &handle);
+
+  // Allow calling this from the compositor thread.
+  if (MessageLoop::current() == message_loop())
+    success = ChildThread::Send(message);
+  else
+    success = sync_message_filter()->Send(message);
+
+  if (!success)
+    return scoped_ptr<base::SharedMemory>();
+
+  if (!base::SharedMemory::IsHandleValid(handle))
+    return scoped_ptr<base::SharedMemory>();
+
+  return scoped_ptr<base::SharedMemory>(new base::SharedMemory(handle, false));
+//#endif  // defined(OS_WIN)
 }
 
 void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
   WebScriptController::registerExtension(extension);
 }
 
 void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
   idle_notification_delay_in_ms_ = initial_delay_ms;
   idle_timer_.Stop();
   idle_timer_.Start(FROM_HERE,
@@ skipping 165 matching lines @@
 scoped_refptr<base::MessageLoopProxy> RenderThreadImpl::GetIOLoopProxy() {
   return ChildProcess::current()->io_message_loop_proxy();
 }
 
 base::WaitableEvent* RenderThreadImpl::GetShutDownEvent() {
   return ChildProcess::current()->GetShutDownEvent();
 }
 
 scoped_ptr<base::SharedMemory> RenderThreadImpl::AllocateSharedMemory(
     uint32 size) {
-  base::SharedMemoryHandle handle;
-  bool success;
-  IPC::Message* message =
-      new ChildProcessHostMsg_SyncAllocateSharedMemory(size, &handle);
-
-  // Allow calling this from the compositor thread.
-  if (MessageLoop::current() == message_loop())
-    success = ChildThread::Send(message);
-  else
-    success = sync_message_filter()->Send(message);
-
-  if (!success)
-    return scoped_ptr<base::SharedMemory>();
-
-  if (!base::SharedMemory::IsHandleValid(handle))
-    return scoped_ptr<base::SharedMemory>();
-  return scoped_ptr<base::SharedMemory>(new base::SharedMemory(handle, false));
+  return scoped_ptr<base::SharedMemory>(
+      HostAllocateSharedMemoryBuffer(size));
 }
 
 int32 RenderThreadImpl::CreateViewCommandBuffer(
       int32 surface_id, const GPUCreateCommandBufferConfig& init_params) {
   TRACE_EVENT1("gpu",
                "RenderThreadImpl::CreateViewCommandBuffer",
                "surface_id",
                surface_id);
 
   int32 route_id = MSG_ROUTING_NONE;
@@ skipping 184 matching lines @@
 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
   DCHECK(message_loop() == MessageLoop::current());
   if (!file_thread_.get()) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }
 
 }  // namespace content