Implement StreamTexture::BindTexImage.

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/image_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace content {
 
 using gpu::gles2::ContextGroup;
 using gpu::gles2::GLES2Decoder;
+using gpu::gles2::ImageManager;
 using gpu::gles2::TextureManager;
 using gpu::gles2::TextureRef;
 
 // static
-bool StreamTexture::Create(
-    GpuCommandBufferStub* owner_stub,
-    uint32 client_texture_id,
-    int stream_id) {
+bool StreamTexture::CreateStreamTextureImage(GpuCommandBufferStub* owner_stub,
+                                             int32 image_id,
+                                             int32 stream_id) {
+  DCHECK(owner_stub);
+  GLES2Decoder* decoder = owner_stub->decoder();
+  DCHECK(decoder);
+  ImageManager* image_manager = decoder->GetImageManager();
+  DCHECK(image_manager);
+  scoped_refptr<StreamTexture> image(
+      new StreamTexture(owner_stub, stream_id, 0));
+  image_manager->AddImage(image.get(), image_id);
+  return true;
+}
+
+// static
+bool StreamTexture::CreateStreamTexture(GpuCommandBufferStub* owner_stub,
+                                        uint32 client_texture_id,
+                                        int 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<gfx::GLImage> 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());
     return true;
   }
 
   return false;
 }
 
 StreamTexture::StreamTexture(GpuCommandBufferStub* owner_stub,
                              int32 route_id,
-                             uint32 texture_id)
+                             int32 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_) {
@@ skipping 108 matching lines @@
   if (!owner_stub_)
     return;
 
   base::ProcessHandle process = owner_stub_->channel()->renderer_pid();
 
   SurfaceTexturePeer::GetInstance()->EstablishSurfaceTexturePeer(
       process, surface_texture_, primary_id, secondary_id);
 }
 
 bool StreamTexture::BindTexImage(unsigned target) {
-  NOTREACHED();
-  return false;
+  TRACE_EVENT0("gpu", "StreamTexture::BindTexImage");
+  DCHECK(surface_texture_.get());
+  if (!owner_stub_ || !surface_texture_.get())
+    return false;
+
+  if (target != GL_TEXTURE_EXTERNAL_OES) {
+    LOG(ERROR)
+        << "Surface texture can only be bound to TEXTURE_EXTERNAL_OES target";
+    return false;
+  }
+
+  GLint texture_id;
+  glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texture_id);
+  DCHECK(texture_id);
+  if (!texture_id_)
+    texture_id_ = texture_id;
+  if (texture_id_ && texture_id_ != texture_id) {
+    LOG(ERROR) << "Surface texture can only be bound to one texture ID";
+    return false;
+  }
+  // Note: Surface textures used as gpu memory buffers are created with an
+  // initial dummy texture id of 0. We need to call DetachFromGLContext() here
+  // to detach from the dummy texture before we can attach to a real texture
+  // id. DetachFromGLContext() will delete the texture for the current
+  // attachment point so it's important that this is never called when
+  // attached to a real texture id. Detaching from the dummy texture id should
+  // not cause any problems as the GL should silently ignore 0 when passed to
+  // glDeleteTextures.
+  surface_texture_->DetachFromGLContext();
+  // This will attach the surface texture to the texture currently bound to
+  // GL_TEXTURE_EXTERNAL_OES target.
+  surface_texture_->AttachToGLContext();
+
+  surface_texture_->UpdateTexImage();
+  return true;
 }
 
 void StreamTexture::ReleaseTexImage(unsigned target) {
   NOTREACHED();
 }
 
 bool StreamTexture::CopyTexSubImage(unsigned target,
                                     const gfx::Point& offset,
                                     const gfx::Rect& rect) {
   return false;
 }
 
 bool StreamTexture::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                          int z_order,
                                          gfx::OverlayTransform transform,
                                          const gfx::Rect& bounds_rect,
                                          const gfx::RectF& crop_rect) {
   NOTREACHED();
   return false;
 }
 
 }  // namespace content