Allow WebExternalTextureLayers to receive a bitmap along with a mailbox

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 87 matching lines @@
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebSharedWorkerRepository.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
 #include "v8/include/v8.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/child/worker_task_runner.h"
 #include "webkit/renderer/appcache/appcache_frontend_impl.h"
+#include "webkit/renderer/compositor_bindings/web_external_bitmap_impl.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <objbase.h>
 #include "base/win/scoped_com_initializer.h"
 #else
 // TODO(port)
 #include "base/memory/scoped_handle.h"
 #include "content/child/np_channel_base.h"
 #endif
@@ skipping 91 matching lines @@
       histogram_name, min, max, buckets,
       base::Histogram::kUmaTargetedHistogramFlag);
   return histogram;
 }
 
 void AddHistogramSample(void* hist, int sample) {
   base::Histogram* histogram = static_cast<base::Histogram*>(hist);
   histogram->Add(sample);
 }
 
+scoped_ptr<base::SharedMemory> AllocateSharedMemoryFunction(size_t size) {
+  return RenderThreadImpl::Get()->HostAllocateSharedMemoryBuffer(size);
+}
+
 }  // namespace
 
 class RenderThreadImpl::GpuVDAContextLostCallback
     : public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
   GpuVDAContextLostCallback()
       : main_message_loop_(base::MessageLoopProxy::current()) {}
   virtual ~GpuVDAContextLostCallback() {}
   virtual void onContextLost() {
     main_message_loop_->PostTask(FROM_HERE, base::Bind(
@@ skipping 487 matching lines @@
     WebRuntimeFeatures::enableWebAudio(false);
   }
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
 
   devtools_agent_message_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_message_filter_.get());
 
   if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
     ScheduleIdleHandler(kLongIdleHandlerDelayMs);
+
+  webkit::SetSharedMemoryAllocationFunction(AllocateSharedMemoryFunction);
 }
 
 void RenderThreadImpl::RegisterSchemes() {
   // swappedout: pages should not be accessible, and should also
   // be treated as empty documents that can commit synchronously.
   WebString swappedout_scheme(ASCIIToUTF16(chrome::kSwappedOutScheme));
   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(swappedout_scheme);
   WebSecurityPolicy::registerURLSchemeAsEmptyDocument(swappedout_scheme);
 
   // chrome-native: is a scheme used for placeholder navigations that allow
@@ skipping 12 matching lines @@
 
 void RenderThreadImpl::RecordUserMetrics(const std::string& action) {
   Send(new ViewHostMsg_UserMetricsRecordAction(action));
 }
 
 scoped_ptr<base::SharedMemory>
     RenderThreadImpl::HostAllocateSharedMemoryBuffer(size_t size) {
   if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
     return scoped_ptr<base::SharedMemory>();
 
+#if defined(OS_POSIX)
   base::SharedMemoryHandle handle;
   bool success;
   IPC::Message* message =
       new ChildProcessHostMsg_SyncAllocateSharedMemory(size, &handle);
 
   // Allow calling this from the compositor thread.
   if (base::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));
+#else
+  scoped_ptr<base::SharedMemory> memory(new base::SharedMemory);
+
+  if (!memory->CreateAndMapAnonymous(size))
+    return scoped_ptr<base::SharedMemory>();
+  return memory.Pass();
+#endif
 }
 
 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 473 matching lines @@
 
 void RenderThreadImpl::SetFlingCurveParameters(
     const std::vector<float>& new_touchpad,
     const std::vector<float>& new_touchscreen) {
   webkit_platform_support_->SetFlingCurveParameters(new_touchpad,
                                                     new_touchscreen);
 
 }
 
 }  // namespace content