content: Add multi-proc surface texture support.

content/common/gpu/gpu_channel_manager.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/common/gpu/gpu_channel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/sync_point_manager.h"
 #include "content/common/message_router.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_share_group.h"
 
+#if defined(OS_ANDROID)
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/lazy_instance.h"
+#include "ui/gl/android/scoped_java_surface.h"
+#include "ui/gl/android/surface_texture.h"
+#include "ui/gl/android/surface_texture_tracker.h"
+#endif
+
 namespace content {
 
+#if defined(OS_ANDROID)
+namespace {
+
+class SurfaceTextureTrackerImpl : public gfx::SurfaceTextureTracker {
+ public:
+  SurfaceTextureTrackerImpl() {
+    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;
+  }
+
+  void AddSurfaceTexture(gfx::SurfaceTexture* surface_texture,
+                         int surface_texture_id,
+                         base::ProcessHandle process_handle) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    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)));
+  }
+
+  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();
+  }
+
+ 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_;
+  base::ThreadChecker thread_checker_;
+};
+base::LazyInstance<SurfaceTextureTrackerImpl> g_surface_texture_tracker =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+#endif  // OS_ANDROID
+
 GpuChannelManager::ImageOperation::ImageOperation(
     int32 sync_point, base::Closure callback)
     : sync_point(sync_point),
       callback(callback) {
 }
 
 GpuChannelManager::ImageOperation::~ImageOperation() {
 }
 
 GpuChannelManager::GpuChannelManager(MessageRouter* router,
                                      GpuWatchdog* watchdog,
                                      base::MessageLoopProxy* io_message_loop,
                                      base::WaitableEvent* shutdown_event)
     : weak_factory_(this),
       io_message_loop_(io_message_loop),
       shutdown_event_(shutdown_event),
       router_(router),
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       watchdog_(watchdog),
       sync_point_manager_(new SyncPointManager) {
   DCHECK(router_);
   DCHECK(io_message_loop);
   DCHECK(shutdown_event);
+  // SurfaceTextureTracker instance must be set before we establish a channel
+  // that could be using it to initialize GLImage instances.
+  gfx::SurfaceTextureTracker::InitInstance(g_surface_texture_tracker.Pointer());
 }
 
 GpuChannelManager::~GpuChannelManager() {
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = NULL;
   }
   DCHECK(image_operations_.empty());
 }
@@ skipping 39 matching lines @@
   bool msg_is_ok = true;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(GpuChannelManager, msg, msg_is_ok)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
                         OnCreateViewCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateImage, OnCreateImage)
     IPC_MESSAGE_HANDLER(GpuMsg_DeleteImage, OnDeleteImage)
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
+    IPC_MESSAGE_HANDLER(GpuMsg_CreateSurfaceTexture, OnCreateSurfaceTexture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 bool GpuChannelManager::Send(IPC::Message* msg) { return router_->Send(msg); }
 
 void GpuChannelManager::OnEstablishChannel(int client_id, bool share_context) {
   IPC::ChannelHandle channel_handle;
 
@@ skipping 140 matching lines @@
 
 bool GpuChannelManager::HandleMessagesScheduled() {
   for (GpuChannelMap::iterator iter = gpu_channels_.begin();
        iter != gpu_channels_.end(); ++iter) {
     if (iter->second->handle_messages_scheduled())
       return true;
   }
   return false;
 }
 
+void GpuChannelManager::OnCreateSurfaceTexture(
+    int32 surface_texture_id, int32 process_handle) {
+  DCHECK(surface_texture_id);
+#if defined(OS_ANDROID)
+  const int kDummyTextureId = 0;
+  scoped_refptr<gfx::SurfaceTexture> surface_texture =
+      gfx::SurfaceTexture::Create(kDummyTextureId);
+  g_surface_texture_tracker.Pointer()->AddSurfaceTexture(
+      surface_texture.get(),
+      surface_texture_id,
+      static_cast<base::ProcessHandle>(process_handle));
+#endif  // OS_ANDROID
+}
+
 uint64 GpuChannelManager::MessagesProcessed() {
   uint64 messages_processed = 0;
 
   for (GpuChannelMap::iterator iter = gpu_channels_.begin();
        iter != gpu_channels_.end(); ++iter) {
     messages_processed += iter->second->messages_processed();
   }
   return messages_processed;
 }
 
@@ skipping 14 matching lines @@
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(1, 1));
   }
   return default_offscreen_surface_.get();
 }
 
 }  // namespace content