gpu: introduce glSetStreamTextureSizeCHROMIUM(GLuint texture, GLint stream_id, GLsizei width, GLsiz…

content/common/gpu/stream_texture_android.cc

 // Copyright (c) 2013 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/stream_texture_android.h"
 
 #include "base/bind.h"
 #include "content/common/android/surface_texture_peer.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/texture_manager.h"
+#include "ipc/ipc_listener.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_image.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace content {
 
 using gpu::gles2::ContextGroup;
 using gpu::gles2::GLES2Decoder;
 using gpu::gles2::TextureManager;
 using gpu::gles2::TextureRef;
 
+class StreamTexture : public gl::GLImage,
+                      public IPC::Listener,
+                      public GpuCommandBufferStub::DestructionObserver {
+ public:
+  static scoped_refptr<StreamTexture> Create(GpuCommandBufferStub* owner_stub,
+                                             uint32 client_texture_id,
+                                             int32 stream_id);
+
+  void SetReleaseCallback(const base::Closure& release_callback) {
+    release_callback_ = release_callback;
+  }
+  void SetSize(GpuCommandBufferStub* owner_stub,
+               uint32 client_texture_id,
+               size_t width,
+               size_t height) {
+    size_.SetSize(width, height);
+
+    GLES2Decoder* decoder = owner_stub->decoder();
+    TextureManager* texture_manager =
+        decoder->GetContextGroup()->texture_manager();
+    TextureRef* texture = texture_manager->GetTexture(client_texture_id);
+    if (!texture || (texture->texture()->target() &&
+                     texture->texture()->target() != GL_TEXTURE_EXTERNAL_OES)) {
+      return;
+    }
+
+    // Prevent deletion on SetLevelInfo()
+    scoped_refptr<StreamTexture> gl_image = this;
+    texture_manager->SetLevelInfo(
+        texture, GL_TEXTURE_EXTERNAL_OES, 0, GetInternalFormat(), width, height,
+        1, 0, GetInternalFormat(), GL_UNSIGNED_BYTE, gfx::Rect(size_));
+    texture_manager->SetLevelImage(texture, GL_TEXTURE_EXTERNAL_OES, 0,
+                                   gl_image.get(),
+                                   gpu::gles2::Texture::UNBOUND);
+  }
+
+ private:
+  StreamTexture(GpuCommandBufferStub* owner_stub,
+                int32 route_id,
+                uint32 texture_id);
+  ~StreamTexture() override;
+
+  // gl::GLImage implementation:
+  void Destroy(bool have_context) override;
+  gfx::Size GetSize() override;
+  unsigned GetInternalFormat() override;
+  bool BindTexImage(unsigned target) override;
+  void ReleaseTexImage(unsigned target) override;
+  bool CopyTexImage(unsigned target) override;
+  bool CopyTexSubImage(unsigned target,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                            int z_order,
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
+
+  // GpuCommandBufferStub::DestructionObserver implementation.
+  void OnWillDestroyStub() override;
+
+  // Called when a new frame is available for the SurfaceTexture.
+  void OnFrameAvailable();
+
+  // IPC::Listener implementation:
+  bool OnMessageReceived(const IPC::Message& message) override;
+
+  // IPC message handlers:
+  void OnStartListening();
+  void OnEstablishPeer(int32 primary_id, int32 secondary_id);
+
+  scoped_refptr<gfx::SurfaceTexture> surface_texture_;
+
+  // Current transform matrix of the surface texture.
+  float current_matrix_[16];
+
+  // Current size of the surface texture.
+  gfx::Size size_;
+
+  // Whether we ever bound a valid frame.
+  bool has_valid_frame_;
+
+  // Whether a new frame is available that we should update to.
+  bool has_pending_frame_;
+
+  GpuCommandBufferStub* owner_stub_;
+  int32 route_id_;
+  bool has_listener_;
+  uint32 texture_id_;
+
+  base::Closure release_callback_;
+
+  base::WeakPtrFactory<StreamTexture> weak_factory_;
+  DISALLOW_COPY_AND_ASSIGN(StreamTexture);
+};
+
 // static
-bool StreamTexture::Create(
+scoped_refptr<StreamTexture> StreamTexture::Create(
     GpuCommandBufferStub* owner_stub,
     uint32 client_texture_id,
-    int stream_id) {
+    int32 stream_id) {
   GLES2Decoder* decoder = owner_stub->decoder();
   TextureManager* texture_manager =
       decoder->GetContextGroup()->texture_manager();
   TextureRef* texture = texture_manager->GetTexture(client_texture_id);
 
   if (texture && (!texture->texture()->target() ||
                   texture->texture()->target() == GL_TEXTURE_EXTERNAL_OES)) {
 
     // TODO: Ideally a valid image id was returned to the client so that
     // it could then call glBindTexImage2D() for doing the following.
-    scoped_refptr<gl::GLImage> gl_image(
+    scoped_refptr<StreamTexture> gl_image(
         new StreamTexture(owner_stub, stream_id, texture->service_id()));
     gfx::Size size = gl_image->GetSize();
     texture_manager->SetTarget(texture, GL_TEXTURE_EXTERNAL_OES);
     texture_manager->SetLevelInfo(texture, GL_TEXTURE_EXTERNAL_OES, 0, GL_RGBA,
                                   size.width(), size.height(), 1, 0, GL_RGBA,
                                   GL_UNSIGNED_BYTE, gfx::Rect(size));
     texture_manager->SetLevelImage(texture, GL_TEXTURE_EXTERNAL_OES, 0,
                                    gl_image.get(),
                                    gpu::gles2::Texture::UNBOUND);
-    return true;
+    return gl_image;
   }
 
-  return false;
+  return nullptr;
 }
 
 StreamTexture::StreamTexture(GpuCommandBufferStub* owner_stub,
                              int32 route_id,
                              uint32 texture_id)
     : surface_texture_(gfx::SurfaceTexture::Create(texture_id)),
       size_(0, 0),
       has_valid_frame_(false),
       has_pending_frame_(false),
       owner_stub_(owner_stub),
       route_id_(route_id),
       has_listener_(false),
       texture_id_(texture_id),
       weak_factory_(this) {
   owner_stub->AddDestructionObserver(this);
   memset(current_matrix_, 0, sizeof(current_matrix_));
   owner_stub->channel()->AddRoute(route_id, this);
   surface_texture_->SetFrameAvailableCallback(base::Bind(
       &StreamTexture::OnFrameAvailable, weak_factory_.GetWeakPtr()));
 }
 
 StreamTexture::~StreamTexture() {
   if (owner_stub_) {
     owner_stub_->RemoveDestructionObserver(this);
     owner_stub_->channel()->RemoveRoute(route_id_);
   }
+  release_callback_.Run();
 }
 
 void StreamTexture::OnWillDestroyStub() {
   owner_stub_->RemoveDestructionObserver(this);
   owner_stub_->channel()->RemoveRoute(route_id_);
   owner_stub_ = NULL;
 
   // If the owner goes away, there is no need to keep the SurfaceTexture around.
   // The GL texture will keep working regardless with the currently bound frame.
   surface_texture_ = NULL;
@@ skipping 97 matching lines @@
 
 unsigned StreamTexture::GetInternalFormat() {
   return GL_RGBA;
 }
 
 bool StreamTexture::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(StreamTexture, message)
     IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_StartListening, OnStartListening)
     IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_EstablishPeer, OnEstablishPeer)
-    IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_SetSize, OnSetSize)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   DCHECK(handled);
   return handled;
 }
 
 void StreamTexture::OnStartListening() {
   DCHECK(!has_listener_);
   has_listener_ = true;
@@ skipping 32 matching lines @@
   NOTREACHED();
   return false;
 }
 
 void StreamTexture::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                                  uint64_t process_tracing_id,
                                  const std::string& dump_name) {
   // TODO(ericrk): Add OnMemoryDump for GLImages. crbug.com/514914
 }
 
+StreamTextureManager::StreamTextureManager() : weak_factory_(this) {}
+
+StreamTextureManager::~StreamTextureManager() {
+  if (!stream_textures_.empty()) {
+    LOG(WARNING) << "Undestroyed stream textures while tearing down "
+                    "StreamTextureManager.";
+  }
+}
+
+bool StreamTextureManager::CreateStreamTexture(GpuCommandBufferStub* owner_stub,
+                                               uint32 client_texture_id,
+                                               int32 stream_id) {
+  CalledOnValidThread();
+  DCHECK_EQ(static_cast<size_t>(0), stream_textures_.count(stream_id));
+  scoped_refptr<StreamTexture> stream_texture =
+      StreamTexture::Create(owner_stub, client_texture_id, stream_id);
+  if (!stream_texture)
+    return false;
+  base::Closure release_callback =
+      base::Bind(&StreamTextureManager::OnReleaseStreamTexture,
+                 weak_factory_.GetWeakPtr(), stream_id);
+  stream_texture->SetReleaseCallback(release_callback);
+  stream_textures_[stream_id] = stream_texture.get();
+  return true;
+}
+
+void StreamTextureManager::SetStreamTextureSize(
+    GpuCommandBufferStub* owner_stub,
+    uint32 client_texture_id,
+    int32 stream_id,
+    size_t width,
+    size_t height) {
+  CalledOnValidThread();
+  if (!stream_textures_.count(stream_id))
+    return;
+  stream_textures_[stream_id]->SetSize(owner_stub, client_texture_id, width,
+                                       height);
+}
+
+void StreamTextureManager::OnReleaseStreamTexture(int32 stream_id) {
+  CalledOnValidThread();
+  DCHECK_EQ(static_cast<size_t>(1), stream_textures_.count(stream_id));
+  stream_textures_.erase(stream_id);
+}
+
 }  // namespace content