Add initial GpuMemoryBufferSurfaceTexture implementation.

content/app/android/child_process_service.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/app/android/child_process_service.h"
 
 #include <android/native_window_jni.h>
 #include <cpu-features.h>
 
 #include "base/android/jni_array.h"
 #include "base/android/library_loader/library_loader_hooks.h"
 #include "base/android/memory_pressure_listener_android.h"
 #include "base/logging.h"
 #include "base/posix/global_descriptors.h"
 #include "content/child/child_thread.h"
+#include "content/common/android/surface_texture_lookup.h"
 #include "content/common/android/surface_texture_peer.h"
 #include "content/common/gpu/gpu_surface_lookup.h"
 #include "content/public/app/android_library_loader_hooks.h"
 #include "content/public/common/content_descriptors.h"
 #include "ipc/ipc_descriptors.h"
 #include "jni/ChildProcessService_jni.h"
 #include "ui/gl/android/scoped_java_surface.h"
 
 using base::android::AttachCurrentThread;
 using base::android::CheckException;
@@ skipping 46 matching lines @@
     return native_window;
   }
 
  private:
   // The instance of org.chromium.content.app.ChildProcessService.
   base::android::ScopedJavaGlobalRef<jobject> service_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceTexturePeerChildImpl);
 };
 
+class SurfaceTextureLookupChildImpl : public content::SurfaceTextureLookup {
+ public:
+  // |service| is the instance of
+  // org.chromium.content.app.ChildProcessService.
+  explicit SurfaceTextureLookupChildImpl(
+      const base::android::ScopedJavaLocalRef<jobject>& service)

[no sievers, 2014/03/14 01:24:51]

Do you maybe just fold this into the existing SurfaceTexturePeerChildImpl above
instead? Then we need one less new interface.

It should really be renamed, but it's already used for similar things happening
both from renderer and gpu child process.

[reveman, 2014/03/14 19:44:53]

To fold this into the above class I'd like to merge
content::SurfaceTextureLookup with content::GpuSurfaceLookup and not have two
different AcquireNativeWidget functions somehow. Any suggestions for how to do
that? Maybe ChildProcessService_getSurfaceTextureSurface can be used in both
cases and establishSurfaceTexturePeer will register the surface with the
SurfaceTextureTrackerImpl on the browser side.

I'm very interested unifying as much as possible of this code but maybe better
to do this as a follow up? I'm reluctant to making too many changes to existing
code paths in this initial patch.

[no sievers, 2014/03/18 20:58:12]

For the view surface lookup, it's slightly different: GpuSurfaceTracker lives in
the browser and implements GpuSurfaceLookup for in-process-gpu. For
out-of-process-gpu it uses  SurfaceTexturePeerChildImp to implement
GpuSurfaceLookup which then goes to the browser. It would be nice to refactor it
so that it also ends up talking to GpuSurfaceTracker in the browser in the
second case, instead of talking to CompositorImpl there. But it would need some
opaque type to be returned from GpuSurfaceTracker so that we can get to the Java
Surface.

Still not fully sure if it's feasible to merge it with this usage case, because
in this case we then would really need to go from the browser and forward the
lookup to the GPU process, while for the view surface the lookup is in the
reverse direction.

Overall definitely sounds more like a follow-up thing. But still seems find to
merge the interface here into the above on the client side here, since you also
merge it into the existing .aidl binder interface anyway.

+      : service_(service) {}
+
+  virtual gfx::AcceleratedWidget AcquireNativeWidget(int surface_texture_id)
+      OVERRIDE {
+    JNIEnv* env = base::android::AttachCurrentThread();
+    gfx::ScopedJavaSurface surface(
+        content::Java_ChildProcessService_getSurfaceTextureSurface(
+            env, service_.obj(), surface_texture_id));
+
+    if (surface.j_surface().is_null())
+      return NULL;
+
+    ANativeWindow* native_window =
+        ANativeWindow_fromSurface(env, surface.j_surface().obj());
+
+    return native_window;
+  }
+
+ private:
+  // The instance of org.chromium.content.app.ChildProcessService.
+  base::android::ScopedJavaGlobalRef<jobject> service_;
+
+  DISALLOW_COPY_AND_ASSIGN(SurfaceTextureLookupChildImpl);
+};
+
 // Chrome actually uses the renderer code path for all of its child
 // processes such as renderers, plugins, etc.
 void InternalInitChildProcess(const std::vector<int>& file_ids,
                               const std::vector<int>& file_fds,
                               JNIEnv* env,
                               jclass clazz,
                               jobject context,
                               jobject service_in,
                               jint cpu_count,
                               jlong cpu_features) {
   base::android::ScopedJavaLocalRef<jobject> service(env, service_in);
 
   // Set the CPU properties.
   android_setCpu(cpu_count, cpu_features);
   // Register the file descriptors.
   // This includes the IPC channel, the crash dump signals and resource related
   // files.
   DCHECK(file_fds.size() == file_ids.size());
   for (size_t i = 0; i < file_ids.size(); ++i)
     base::GlobalDescriptors::GetInstance()->Set(file_ids[i], file_fds[i]);
 
   content::SurfaceTexturePeer::InitInstance(
       new SurfaceTexturePeerChildImpl(service));
 
+  // SurfaceTextureLookup instance must be set before we create a compositor
+  // thread that could be using it to initialize resources.
+  content::SurfaceTextureLookup::InitInstance(
+      new SurfaceTextureLookupChildImpl(service));
+
   base::android::MemoryPressureListenerAndroid::RegisterSystemCallback(env);
 }
 
 }  // namespace <anonymous>
 
 void InitChildProcess(JNIEnv* env,
                       jclass clazz,
                       jobject context,
                       jobject service,
                       jintArray j_file_ids,
@@ skipping 18 matching lines @@
 
 bool RegisterChildProcessService(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void ShutdownMainThread(JNIEnv* env, jobject obj) {
   ChildThread::ShutdownThread();
 }
 
 }  // namespace content