Add initial GpuMemoryBufferSurfaceTexture implementation.

content/browser/renderer_host/compositor_impl_android.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/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <map>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_checker.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/resources/scoped_ui_resource.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/public/browser/android/compositor_client.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "ui/base/android/window_android.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/frame_time.h"
+#include "ui/gl/android/scoped_java_surface.h"
+#include "ui/gl/android/surface_texture.h"
+#include "ui/gl/android/surface_texture_tracker.h"
 #include "webkit/common/gpu/context_provider_in_process.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 namespace gfx {
 class JavaBitmap;
 }
 
 namespace {
 
 // Used for drawing directly to the screen. Bypasses resizing and swaps.
@@ skipping 68 matching lines @@
 
  protected:
   TransientUIResource(cc::LayerTreeHost* host,
                       const cc::UIResourceBitmap& bitmap)
       : cc::ScopedUIResource(host, bitmap), retrieved_(false) {}
 
  private:
   bool retrieved_;
 };
 
+class SurfaceTextureTrackerImpl : public gfx::SurfaceTextureTracker {
+ public:
+  SurfaceTextureTrackerImpl() : next_surface_texture_id_(1) {
+    thread_checker_.DetachFromThread();
+  }
+
+  // Overridden from gfx::SurfaceTextureTracker:
+  virtual scoped_refptr<gfx::SurfaceTexture> AcquireSurfaceTexture(
+      int primary_id,
+      int secondary_id) OVERRIDE {
+    base::AutoLock lock(surface_textures_lock_);
+    scoped_ptr<SurfaceTextureInfo> info =
+        surface_textures_.take_and_erase(SurfaceTextureMapKey(
+            primary_id, static_cast<base::ProcessHandle>(secondary_id)));
+    return info ? info->surface_texture : NULL;
+  }
+
+  int AddSurfaceTexture(gfx::SurfaceTexture* surface_texture,
+                        base::ProcessHandle process_handle) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    int surface_texture_id = next_surface_texture_id_++;
+    if (next_surface_texture_id_ == INT_MAX)
+      next_surface_texture_id_ = 1;
+
+    base::AutoLock lock(surface_textures_lock_);
+    SurfaceTextureMapKey key(surface_texture_id, process_handle);
+    DCHECK(surface_textures_.find(key) == surface_textures_.end());
+    surface_textures_.set(
+        key, make_scoped_ptr(new SurfaceTextureInfo(surface_texture)));
+    return surface_texture_id;
+  }
+
+  void RemoveAllSurfaceTextures(base::ProcessHandle process_handle) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    base::AutoLock lock(surface_textures_lock_);
+    SurfaceTextureMap::iterator it = surface_textures_.begin();
+    while (it != surface_textures_.end()) {
+      if (it->first.second == process_handle)
+        surface_textures_.erase(it++);
+      else
+        ++it;
+    }
+  }
+
+  jobject GetSurface(int surface_texture_id,
+                     base::ProcessHandle process_handle) const {
+    base::AutoLock lock(surface_textures_lock_);
+    SurfaceTextureMap::const_iterator it = surface_textures_.find(
+        SurfaceTextureMapKey(surface_texture_id, process_handle));
+    return it == surface_textures_.end()
+               ? NULL
+               : it->second->surface.j_surface().obj();

[piman, 2014/03/27 01:07:25]

Is the jobject returned thread safe? What if RemoveAllSurfaceTextures is called
on one thread while the jobject is used on another thread?

[reveman, 2014/03/27 14:48:11]

Good call. We probably have to take a ref here and hold on to it until the
binder thread is done with the current IPC call. I'll look into this.

@sievers, this is a problem with the existing getViewSurface IPC as well, right?

[no sievers, 2014/03/27 18:25:25]

There are a few things:

- The SurfaceTexture native object, which is RefCountedThreadSafe, which overall
holds one global strong ref to a Java SurfaceTexture. (and otherwise just
forwards calls through JNI to the Java object.)

- The SurfaceTexture Java object which is thread-safe... well.. some APIs can be
called from any thread, others need to be called with a certain context current
(the first one you start using any of those APIs with, such as updateTexImage).

- The Surface Java object which is created from the SurfaceTexture and provides
the producer interface.

- The ScopedJavaSurface which creates such a Java Surface and then holds a
global ref to it.

Now, I *think* there is a small race possible with just returning the naked
obj() handle here, because dalvik will have to go an acquire a ref to it also
(while our mutex might be already released). It's not clear to me from the
documentation whether you have to leak a LocalRef here, so that it only gets
released when you are entirely returning to Java, or if it's maybe good enough
to just create a ScopedLocalRef here (and assume it does the right thing by
deferring the release).
(Or if JNI is entirely protected with locks to prevent such scenarios - I doubt
it.)

I think I'd just create a ScopedLocalRef for the surface obj here to show your
good intention (and avoid a leak) :)

+  }
+
+ private:
+  struct SurfaceTextureInfo {
+    explicit SurfaceTextureInfo(gfx::SurfaceTexture* surface_texture)
+        : surface_texture(surface_texture), surface(surface_texture) {}
+
+    scoped_refptr<gfx::SurfaceTexture> surface_texture;
+    gfx::ScopedJavaSurface surface;
+  };
+
+  typedef std::pair<int, base::ProcessHandle> SurfaceTextureMapKey;
+  typedef base::ScopedPtrHashMap<SurfaceTextureMapKey, SurfaceTextureInfo>
+      SurfaceTextureMap;
+  SurfaceTextureMap surface_textures_;
+  mutable base::Lock surface_textures_lock_;
+  int next_surface_texture_id_;
+  base::ThreadChecker thread_checker_;
+};
+base::LazyInstance<SurfaceTextureTrackerImpl> g_surface_texture_tracker =
+    LAZY_INSTANCE_INITIALIZER;
+
 static bool g_initialized = false;
 
 } // anonymous namespace
 
 namespace content {
 
 typedef std::map<int, base::android::ScopedJavaGlobalRef<jobject> >
     SurfaceMap;
 static base::LazyInstance<SurfaceMap>
     g_surface_map = LAZY_INSTANCE_INITIALIZER;
 static base::LazyInstance<base::Lock> g_surface_map_lock;
 
 // static
 Compositor* Compositor::Create(CompositorClient* client,
                                gfx::NativeWindow root_window) {
   return client ? new CompositorImpl(client, root_window) : NULL;
 }
 
 // static
 void Compositor::Initialize() {
   DCHECK(!CompositorImpl::IsInitialized());
+  // SurfaceTextureTracker instance must be set before we create a GPU thread
+  // that could be using it to initialize GLImage instances.
+  gfx::SurfaceTextureTracker::InitInstance(g_surface_texture_tracker.Pointer());
   g_initialized = true;
 }
 
 // static
 bool CompositorImpl::IsInitialized() {
   return g_initialized;
 }
 
 // static
 jobject CompositorImpl::GetSurface(int surface_id) {
   base::AutoLock lock(g_surface_map_lock.Get());
   SurfaceMap* surfaces = g_surface_map.Pointer();
   SurfaceMap::iterator it = surfaces->find(surface_id);
   jobject jsurface = it == surfaces->end() ? NULL : it->second.obj();
 
   LOG_IF(WARNING, !jsurface) << "No surface for surface id " << surface_id;
   return jsurface;
 }
 
+// static
+jobject CompositorImpl::GetSurfaceTextureSurface(
+    int surface_texture_id,
+    base::ProcessHandle process_handle) {
+  jobject jsurface = g_surface_texture_tracker.Pointer()->GetSurface(
+      surface_texture_id, process_handle);
+
+  LOG_IF(WARNING, !jsurface) << "No surface for surface texture id "
+                             << surface_texture_id;
+  return jsurface;
+}
+
+// static
+int CompositorImpl::AllocateSurfaceTexture(base::ProcessHandle process_handle) {
+  const int kDummyTextureId = 0;
+  scoped_refptr<gfx::SurfaceTexture> surface_texture =
+      gfx::SurfaceTexture::Create(kDummyTextureId);
+  return g_surface_texture_tracker.Pointer()->AddSurfaceTexture(
+      surface_texture.get(), process_handle);
+}
+
+// static
+void CompositorImpl::DestroyAllSurfaceTextures(
+    base::ProcessHandle process_handle) {
+  g_surface_texture_tracker.Pointer()->RemoveAllSurfaceTextures(process_handle);
+}
+
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create()),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_id_(0),
       client_(client),
       root_window_(root_window) {
   DCHECK(client);
@@ skipping 280 matching lines @@
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   root_layer_->AddChild(layer);
 }
 
 }  // namespace content