Enable SurfaceTexture based zero-copy texture uploading on Android platform

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 1084 matching lines @@
 scoped_ptr<gfx::GpuMemoryBuffer> RenderThreadImpl::AllocateGpuMemoryBuffer(
     size_t width,
     size_t height,
     unsigned internalformat) {
   DCHECK(allocate_gpu_memory_buffer_thread_checker_.CalledOnValidThread());
 
   if (!GpuMemoryBufferImpl::IsFormatValid(internalformat))
     return scoped_ptr<gfx::GpuMemoryBuffer>();
 
   gfx::GpuMemoryBufferHandle handle;
-  bool success;
-  IPC::Message* message =
-      new ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer(width,
-                                                          height,
-                                                          internalformat,
-                                                          &handle);

[reveman, 2014/02/26 08:02:34]

Please don't change any of code in this function. This is currently not a place
for platform or implementation specific code.

Even if you're not going to allocate the SurfaceTexture on the browser process
side (but that might be better, if possible?) still perform this sync IPC for
now and have it return a gfx::GpuMemoryBufferHandle with type set to
gfx::SURFACE_TEXTURE_BUFFER.

Don't worry about the unnecessary round-trip for now. I'd like to see a first
implementation of this that is as clean as possible. Once we've landed that and
have some good data on how it performs we can investigate Android specific
shortcuts that will improve performance.

The cost of the round-trip here has to be reduced anyhow (crbug.com/346712) so
it's likely not going to be a problem in the long run.

 
-  // 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 defined(OS_ANDROID)
+  bool is_android = true;
+#else
+  bool is_android = false;
+#endif
 
-  if (!success)
-    return scoped_ptr<gfx::GpuMemoryBuffer>();
+  if (!is_android || !CommandLine::ForCurrentProcess()->HasSwitch(
+                          switches::KEnableSurfaceTextureBuffer)) {
+    bool success;
+    IPC::Message* message = new ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer(
+        width, height, internalformat, &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<gfx::GpuMemoryBuffer>();
+  } else
+    handle.type = gfx::SURFACE_TEXTURE_BUFFER;
 
   return GpuMemoryBufferImpl::Create(
       handle,
       gfx::Size(width, height),
       internalformat).PassAs<gfx::GpuMemoryBuffer>();
 }
 
 void RenderThreadImpl::DoNotSuspendWebKitSharedTimer() {
   suspend_webkit_shared_timer_ = false;
 }
@@ skipping 285 matching lines @@
   hidden_widget_count_--;
 
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 }  // namespace content