Remove StreamTextureManager

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 35 matching lines @@
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
-#include "gpu/command_buffer/service/stream_texture.h"
-#include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_MACOSX)
@@ skipping 649 matching lines @@
   }
 
   VertexArrayManager* vertex_array_manager() {
     return vertex_array_manager_.get();
   }
 
   MemoryTracker* memory_tracker() {
     return group_->memory_tracker();
   }
 
-  StreamTextureManager* stream_texture_manager() const {
-    return group_->stream_texture_manager();
-  }
-
   bool EnsureGPUMemoryAvailable(size_t estimated_size) {
     MemoryTracker* tracker = memory_tracker();
     if (tracker) {
       return tracker->EnsureGPUMemoryAvailable(estimated_size);
     }
     return true;
   }
 
   bool IsOffscreenBufferMultisampled() const {
     return offscreen_target_samples_ > 1;
@@ skipping 3134 matching lines @@
   Texture* texture = texture_ref->texture();
 
   // Check the texture exists
   // Check that we are not trying to bind it to a different target.
   if (texture->target() != 0 && texture->target() != target) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexture", "texture bound to more than 1 target.");
     return;
   }
-  if (texture->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glBindTexture", "illegal target for stream texture.");
-    return;
-  }
   LogClientServiceForInfo(texture, client_id, "glBindTexture");
   if (texture->target() == 0) {
     texture_manager()->SetTarget(texture_ref, target);
   }
   glBindTexture(target, texture->service_id());
 
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
@@ skipping 1762 matching lines @@
     // We know there will be no errors, because we only defer compilation on
     // shaders that were previously compiled successfully.
     program_manager()->ForceCompileShader(shader->deferred_compilation_source(),
                                           shader,
                                           translator,
                                           feature_info_.get());
   }
 }
 
 void GLES2DecoderImpl::UpdateStreamTextureIfNeeded(Texture* texture) {
-  if (texture && texture->IsStreamTexture()) {
-    DCHECK(stream_texture_manager());
-    StreamTexture* stream_tex =
-        stream_texture_manager()->LookupStreamTexture(texture->service_id());
-    if (stream_tex)
-      stream_tex->Update();
+  if (features().chromium_stream_texture && texture &&
+      texture->target() == GL_TEXTURE_EXTERNAL_OES) {
+    scoped_refptr<gfx::GLImage> stream_tex =
+        texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0);
+    if (stream_tex.get())
+      stream_tex->UpdateTexImage();
   }
 }
 
 bool GLES2DecoderImpl::PrepareTexturesForRender() {
   DCHECK(state_.current_program.get());
   bool have_unrenderable_textures =
       texture_manager()->HaveUnrenderableTextures();
   if (!have_unrenderable_textures && !features().oes_egl_image_external) {
     return true;
   }
@@ skipping 3790 matching lines @@
   *result = GL_ZERO;
   TextureRef* texture_ref = texture_manager()->GetTexture(client_id);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glCreateStreamTextureCHROMIUM", "bad texture id.");
     return error::kNoError;
   }
 
   Texture* texture = texture_ref->texture();
-  if (texture->IsStreamTexture()) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glCreateStreamTextureCHROMIUM", "is already a stream texture.");
-    return error::kNoError;
-  }
-
   if (texture->target() && texture->target() != GL_TEXTURE_EXTERNAL_OES) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCreateStreamTextureCHROMIUM",
         "is already bound to incompatible target.");
     return error::kNoError;
+  } else if (!texture->target()) {
+    texture_manager()->SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
   }
 
-  if (!stream_texture_manager())
-    return error::kInvalidArguments;
+  scoped_refptr<gfx::GLImage> image =
+      gfx::GLImage::CreateGLImageForStreamTexture(texture->service_id());

[piman, 2013/08/12 23:22:07]

General question: is it ok for the GLImage to outlive the service id?

In the previous code, the whole infrastructure would tear down the StreamTexture
when the last reference to the texture on this context group was released (in
TextureManager::StopTracking), ensuring this. It was a bit of a hack (and not
compatible with ÜC), so I'm glad it's gone, but now the GLImage may outlive the
texture (if the user doesn't explicitly call DestroyStreamTexture).

[no sievers, 2013/08/13 00:21:35]

I think it should be harmless, at least with the current entry points.

From looking at the current SurfaceTexture implementation, it seems like it does
not delete the texture for you during destruction (you construct the
SurfaceTexture from a GL texture). And it's a GC-collected Java object so you
cannot guarantee order anyways.

The only thing I can imagine going wrong would be:
1) the texture gets deleted (unbound and deleted)
2) eventually the driver returns the same texture name from glGenTextures()
3) we call UpdateTexImage() which binds the (still valid) EGLimage to the new
texture with the same name - now our tracking is messed up

3) cannot happen with the current entry points, because you cannot rebind the
GLimage to a new texture. But we need to make sure that stays the case (for
example if I added glBindTexImageExternal). The
GLImageStream::BindTexImageExternal()/ReleaseTexImageExternal() functions I
added actually do the right thing already (they change the binding to a new GL
texture).

 
-  GLuint object_id = stream_texture_manager()->CreateStreamTexture(
-      texture->service_id(), client_id);
-
-  if (object_id) {
-    texture_manager()->SetStreamTexture(texture_ref, true);
+  uint32 image_id = 0;
+  if (image) {
+    image_id = group_->GetIdAllocator(id_namespaces::kImages)->AllocateID();
+    image_manager()->AddImage(image, image_id);
+    texture_manager()->SetLevelInfo(texture_ref,
+                                    GL_TEXTURE_EXTERNAL_OES,
+                                    0,
+                                    GL_RGBA,
+                                    0,
+                                    0,
+                                    1,
+                                    0,
+                                    GL_RGBA,
+                                    GL_UNSIGNED_BYTE,
+                                    true);
+    texture_manager()->SetLevelImage(
+        texture_ref, GL_TEXTURE_EXTERNAL_OES, 0, image);
   } else {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY,
         "glCreateStreamTextureCHROMIUM", "failed to create platform texture.");
   }
 
-  *result = object_id;
+  *result = image_id;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDestroyStreamTextureCHROMIUM(
     uint32 immediate_data_size,
     const cmds::DestroyStreamTextureCHROMIUM& c) {
-  GLuint client_id = c.texture;
-  TextureRef* texture_ref = texture_manager()->GetTexture(client_id);
-  if (texture_ref && texture_manager()->IsStreamTextureOwner(texture_ref)) {
-    if (!stream_texture_manager())
-      return error::kInvalidArguments;
-
-    stream_texture_manager()->DestroyStreamTexture(texture_ref->service_id());
-    texture_manager()->SetStreamTexture(texture_ref, false);
+  GLuint image_id = c.texture;
+  if (image_id && image_manager()->LookupImage(image_id)) {
+    image_manager()->RemoveImage(image_id);
+    group_->GetIdAllocator(id_namespaces::kImages)->FreeID(image_id);
   } else {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDestroyStreamTextureCHROMIUM", "bad texture id.");
   }
 
   return error::kNoError;
 }
 
 #if defined(OS_MACOSX)
@@ skipping 191 matching lines @@
                                            source_height, 1)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureCHROMIUM", "Bad dimensions");
       return;
     }
   }
 
   if (source_texture->target() == GL_TEXTURE_EXTERNAL_OES) {
     UpdateStreamTextureIfNeeded(source_texture);
-    DCHECK(stream_texture_manager());
-    StreamTexture* stream_tex =
-        stream_texture_manager()->LookupStreamTexture(
-            source_texture->service_id());
+    scoped_refptr<gfx::GLImage> stream_tex =
+        source_texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0);
     if (!stream_tex) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureChromium", "Stream texture lookup failed");
       return;
     }
     gfx::Size size = stream_tex->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
@@ skipping 745 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu