content: Out-of-process GPU service support for SurfaceTexture backed GpuMemoryBuffers.

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_manager.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;
 using base::android::JavaIntArrayToIntVector;
 
 namespace content {
 
 namespace {
 
-class SurfaceTexturePeerChildImpl : public SurfaceTexturePeer,
-                                    public GpuSurfaceLookup,
-                                    public SurfaceTextureLookup {
+class SurfaceTextureManagerImpl : public SurfaceTextureManager,
+                                  public SurfaceTexturePeer,
+                                  public GpuSurfaceLookup {
  public:
   // |service| is the instance of
   // org.chromium.content.app.ChildProcessService.
-  explicit SurfaceTexturePeerChildImpl(
+  explicit SurfaceTextureManagerImpl(
       const base::android::ScopedJavaLocalRef<jobject>& service)
       : service_(service) {
+    SurfaceTexturePeer::InitInstance(this);
     GpuSurfaceLookup::InitInstance(this);
-    SurfaceTextureLookup::InitInstance(this);
+  }

[no sievers, 2014/10/07 22:12:45]

One thing I don't like so much is that this class mixes functions that are
exclusively used either by renderers (EstablishPeer, AcquireNativeWidget for ST)
or by the gpu process (AcquireNativeWidget for view surface, Register,
Unregister).
But it was like that before this patch. Maybe I can follow up and see if there
is an easy way to find to instantiate one of two implementations here. I think
it would make it easier to follow things. Mind putting a TODO?

[reveman, 2014/10/08 15:56:39]

Done.

+  virtual ~SurfaceTextureManagerImpl() {
+    SurfaceTexturePeer::InitInstance(NULL);
+    GpuSurfaceLookup::InitInstance(NULL);

[no sievers, 2014/10/07 22:12:45]

Should it also do SurfaceTextureManager::InitInstance(NULL)?

[reveman, 2014/10/08 15:56:39]

That's the responsibility of InternalInitChildProcess. Currently it just sets
and forgets this interface. Which is a bit nasty and something we might want to
clean up but that's not new to this patch.

   }
 
-  virtual ~SurfaceTexturePeerChildImpl() {
-    GpuSurfaceLookup::InitInstance(NULL);
-    SurfaceTextureLookup::InitInstance(NULL);
+  // Overridden from SurfaceTextureManager:
+  virtual void RegisterSurfaceTexture(
+      int surface_texture_id,
+      int client_id,
+      gfx::SurfaceTexture* surface_texture) OVERRIDE {
+    JNIEnv* env = base::android::AttachCurrentThread();
+    gfx::ScopedJavaSurface surface(surface_texture);
+    Java_ChildProcessService_registerSurfaceTextureSurface(
+        env,
+        service_.obj(),
+        surface_texture_id,
+        client_id,
+        surface.j_surface().obj());
+    DCHECK(!base::android::HasException(env));
   }
-
-  // Overridden from SurfaceTexturePeer:
-  virtual void EstablishSurfaceTexturePeer(
-      base::ProcessHandle pid,
-      scoped_refptr<gfx::SurfaceTexture> surface_texture,
-      int primary_id,
-      int secondary_id) OVERRIDE {
+  virtual void UnregisterSurfaceTexture(int surface_texture_id,
+                                        int client_id) OVERRIDE {
     JNIEnv* env = base::android::AttachCurrentThread();
-    content::Java_ChildProcessService_establishSurfaceTexturePeer(
-        env, service_.obj(), pid,
-        surface_texture->j_surface_texture().obj(), primary_id,
-        secondary_id);
-    CheckException(env);
+    Java_ChildProcessService_unregisterSurfaceTextureSurface(
+        env, service_.obj(), surface_texture_id, client_id);
+    DCHECK(!base::android::HasException(env));
   }
-
-  // Overridden from GpuSurfaceLookup:
-  virtual gfx::AcceleratedWidget AcquireNativeWidget(int surface_id) OVERRIDE {
+  virtual gfx::AcceleratedWidget AcquireNativeWidget(int surface_texture_id,
+                                                     int client_id) OVERRIDE {
     JNIEnv* env = base::android::AttachCurrentThread();
     gfx::ScopedJavaSurface surface(
-        content::Java_ChildProcessService_getViewSurface(
-        env, service_.obj(), surface_id));
+        Java_ChildProcessService_getSurfaceTextureSurface(
+            env, service_.obj(), surface_texture_id, client_id));
+    DCHECK(!base::android::HasException(env));
 
     if (surface.j_surface().is_null())
       return NULL;
 
     // Note: This ensures that any local references used by
     // ANativeWindow_fromSurface are released immediately. This is needed as a
     // workaround for https://code.google.com/p/android/issues/detail?id=68174
     base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
     ANativeWindow* native_window =
         ANativeWindow_fromSurface(env, surface.j_surface().obj());
 
     return native_window;
   }
 
-  // Overridden from SurfaceTextureLookup:
-  virtual gfx::AcceleratedWidget AcquireNativeWidget(int primary_id,
-                                                     int secondary_id)
-      OVERRIDE {
+  // Overridden from SurfaceTexturePeer:
+  virtual void EstablishSurfaceTexturePeer(
+      base::ProcessHandle pid,
+      scoped_refptr<gfx::SurfaceTexture> surface_texture,
+      int primary_id,
+      int secondary_id) OVERRIDE {
+    JNIEnv* env = base::android::AttachCurrentThread();
+    content::Java_ChildProcessService_establishSurfaceTexturePeer(
+        env,
+        service_.obj(),
+        pid,
+        surface_texture->j_surface_texture().obj(),
+        primary_id,
+        secondary_id);
+    DCHECK(!base::android::HasException(env));
+  }
+
+  // Overridden from GpuSurfaceLookup:
+  virtual gfx::AcceleratedWidget AcquireNativeWidget(int surface_id) OVERRIDE {
     JNIEnv* env = base::android::AttachCurrentThread();
     gfx::ScopedJavaSurface surface(
-        content::Java_ChildProcessService_getSurfaceTextureSurface(
-            env, service_.obj(), primary_id, secondary_id));
+        content::Java_ChildProcessService_getViewSurface(
+            env, service_.obj(), surface_id));
+    DCHECK(!base::android::HasException(env));
 
     if (surface.j_surface().is_null())
       return NULL;
 
     // Note: This ensures that any local references used by
     // ANativeWindow_fromSurface are released immediately. This is needed as a
     // workaround for https://code.google.com/p/android/issues/detail?id=68174
     base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
     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(SurfaceTexturePeerChildImpl);
+  DISALLOW_COPY_AND_ASSIGN(SurfaceTextureManagerImpl);
 };
 
 // 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]);
 
-  // SurfaceTexturePeerChildImpl implements the SurfaceTextureLookup interface,
-  // which need to be set before we create a compositor thread that could be
-  // using it to initialize resources.
-  content::SurfaceTexturePeer::InitInstance(
-      new SurfaceTexturePeerChildImpl(service));
+  SurfaceTextureManager::InitInstance(new SurfaceTextureManagerImpl(service));
 
   base::android::MemoryPressureListenerAndroid::RegisterSystemCallback(env);
 }
 
 }  // namespace <anonymous>
 
 void InitChildProcess(JNIEnv* env,
                       jclass clazz,
                       jobject context,
                       jobject service,
@@ skipping 19 matching lines @@
 
 bool RegisterChildProcessService(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void ShutdownMainThread(JNIEnv* env, jobject obj) {
   ChildThread::ShutdownThread();
 }
 
 }  // namespace content