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 82 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScriptController.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSharedWorkerRepository.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/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/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 115 matching lines @@
                    const char** arg_names,
                    const unsigned char* arg_types,
                    const unsigned long long* arg_values,
                    unsigned char flags) {
   TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_group_enabled, name, id,
                                   num_args, arg_names, arg_types, arg_values,
                                   NULL, flags);
 }
 #endif
 
+scoped_ptr<base::SharedMemory> AllocateSharedMemoryFunction(size_t size) {
+  return RenderThreadImpl::Get()->HostAllocateSharedMemoryBuffer(size);
+}
+
 }  // namespace
 
 class RenderThreadImpl::GpuVDAContextLostCallback
     : public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
   GpuVDAContextLostCallback() {}
   virtual ~GpuVDAContextLostCallback() {}
   virtual void onContextLost() {
     ChildThread::current()->message_loop()->PostTask(FROM_HERE, base::Bind(
         &RenderThreadImpl::OnGpuVDAContextLoss));
@@ skipping 471 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);
 }
 
 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)

[piman, 2013/07/01 22:45:01]

Why the ifdef? This method was sucessfully used on all platforms previously...

[jbauman, 2013/07/02 00:00:40]

Sure, but I'd prefer not to have a round-trip to the browser
process.ChildThread::AllocateSharedMemory has this same #ifdef logic, but I
guess it wasn't copied over to here.

[piman, 2013/07/02 04:00:09]

I see, that's an optimization. Maybe worth separating out into a CL by itself.
We should also probably delegate to ChildThread::AllocateSharedMemory, passing
|this| or sync_message_filter() as the sender?

[jbauman, 2013/07/02 20:16:19]

Ok, I've removed this change and I'll do that in a separate patch.

   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 476 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