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 "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"
@@ skipping 11 matching lines @@
 #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) {
+    gfx::SurfaceTextureTracker::InitInstance(this);
+  }
+
+  virtual ~SurfaceTextureTrackerImpl() {
+    gfx::SurfaceTextureTracker::InitInstance(NULL);
+  }
+
+  // Overridden from gfx::SurfaceTextureTracker:
+  virtual scoped_refptr<gfx::SurfaceTexture> AcquireSurfaceTexture(
+      int surface_texture_id) OVERRIDE {
+    base::AutoLock lock(surface_textures_lock_);
+    scoped_ptr<SurfaceTextureInfo> info =
+        surface_textures_.take_and_erase(surface_texture_id);
+    return info ? info->surface_texture : NULL;
+  }
+
+  int AddSurfaceTexture(gfx::SurfaceTexture* surface_texture) {
+    int surface_texture_id = next_surface_texture_id_++;
+    base::AutoLock lock(surface_textures_lock_);
+    DCHECK(surface_textures_.find(surface_texture_id) ==
+           surface_textures_.end());
+    surface_textures_.set(
+        surface_texture_id,
+        make_scoped_ptr(new SurfaceTextureInfo(surface_texture)));
+    return surface_texture_id;
+  }
+
+  jobject GetSurface(int surface_texture_id) const {

[reveman, 2014/03/11 22:59:36]

This should probably take a renderer_id to prevent a renderer from stealing a
surface from another renderer.

[reveman, 2014/03/13 21:36:00]

Done.

+    base::AutoLock lock(surface_textures_lock_);
+    SurfaceTextureMap::const_iterator it =
+        surface_textures_.find(surface_texture_id);
+    return it == surface_textures_.end()
+               ? NULL
+               : it->second->surface.j_surface().obj();
+  }
+
+ 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 base::ScopedPtrHashMap<int, SurfaceTextureInfo> SurfaceTextureMap;
+  SurfaceTextureMap surface_textures_;
+  mutable base::Lock surface_textures_lock_;
+  int next_surface_texture_id_;
+};
+base::LazyInstance<SurfaceTextureTrackerImpl> g_surface_texture_tracker =

[epennerAtGoogle, 2014/03/12 00:45:06]

Hold on, I thought the gfx::SurfaceTextureTracker had a global pointer stored in
gfx::SurfaceTextureTracker::InitInstance?   Why does this also store a global
instance?

Anyway, since this is LazyInstance, could it just be moved into
gfx::SurfaceTextureTracker and this one removed?

[reveman, 2014/03/12 16:07:06]

gfx::SurfaceTextureTracker is just an interface and this is one implementation
of that interface. We could have more implementations. ie. one that works with
an out-of-process GPU service.

This doesn't have to be a lazy instance but I found it consistent with
g_surface_map below, which is the other set of surfaces that can be acquired by
the renderer using Java IPC.

[epennerAtGoogle, 2014/03/12 19:46:28]

I think if this doesn't have to be a lazy-instance, it shouldn't be, or if it
should be then the parent global should do it all the time.

[reveman, 2014/03/12 21:19:11]

LazyInstance seems like a good match as we should only have one instance
per-process. Mostly because of how GetSurface() and the Java IPC part works.
What do you mean by "parent global should do it all the time"?

[epennerAtGoogle, 2014/03/12 23:10:14]

Ah, your other comment cleared up why we can't create the lazy instance in the
other class (since LazyInstance needs to know the type!). So forget this part.
See the last question in my other comment.

+    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;
@@ skipping 20 matching lines @@
 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) {
+  jobject jsurface =
+      g_surface_texture_tracker.Pointer()->GetSurface(surface_texture_id);

[epennerAtGoogle, 2014/03/12 00:45:06]

Could CompositorImpl just own this and avoid a global instance? It's nice if it
doesn't need to do thread-safe stuff on every access to the object.

[reveman, 2014/03/12 16:07:06]

We need some thread-safe code here to allow the Java IPC handler to access this.
If this is not global, then the Java IPC handler would have to figure out what
compositorimpl to use. This seems a lot easier and consistent with
g_surface_map..

[epennerAtGoogle, 2014/03/12 19:46:28]

Ahh okay if we've already gone the global route a few times, all good with me
assuming Sievers thinks its okay. We've previously routed these things all the
way to their owners, but maybe it's not necessary.

+
+  LOG_IF(WARNING, !jsurface) << "No surface for surface texture id "
+                             << surface_texture_id;
+  return jsurface;
+}
+
+// static
+int CompositorImpl::AllocateSurfaceTexture() {
+  const int kDummyTextureId = 0;
+  scoped_refptr<gfx::SurfaceTexture> surface_texture =
+      make_scoped_refptr(new gfx::SurfaceTexture(kDummyTextureId));

[epennerAtGoogle, 2014/03/12 00:45:06]

What thread will this happen on? I believe it has to be on a thread that doesn't
have a GL context (in order to do the kDummyTextureId trick).

[reveman, 2014/03/12 16:07:06]

On the IO thread.

Having looked at the SurfaceTexture code, this doesn't seem necessary but that's
of course very fragile as we rely on specifics of the implementation.

[epennerAtGoogle, 2014/03/12 19:46:28]

I think you might be right on the creation part. Unfortunately though, we'll be
relying very heavily on the implementation specifics. However most of the
specifics fall out of the API's constraints, so I don't think any of the
semantics are subject to change.

[reveman, 2014/03/12 21:19:11]

I'll probably switch this over to a real texture id when allocation is moved to
the GPU service side.

+  return g_surface_texture_tracker.Pointer()->AddSurfaceTexture(
+      surface_texture.get());
+}
+
 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 276 matching lines @@
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
   client_->OnSwapBuffersCompleted();
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 } // namespace content