StreamTextureImages can now override a Texture's service id

gpu/command_buffer/service/texture_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 "gpu/command_buffer/service/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 986 matching lines @@
   UpdateCleared();
   UpdateCanRenderCondition();
   UpdateHasImages();
   if (IsAttachedToFramebuffer()) {
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     IncAllFramebufferStateChangeCount();
   }
 }
 
+void Texture::SetStreamTextureServiceId(GLuint service_id) {
+  GLuint new_service_id = service_id ? service_id : owned_service_id_;
+
+  // Take no action if this isn't an OES_EXTERNAL texture.
+  if (target_ && target_ != GL_TEXTURE_EXTERNAL_OES)
+    return;
+
+  if (service_id_ != new_service_id) {
+    service_id_ = new_service_id;
+    IncrementManagerServiceIdGeneration();
+    if (gl::GLContext* context = gl::GLContext::GetCurrent()) {
+      // It would be preferable to pass in the decoder, and ask it to do this
+      // instead.  However, there are several cases, such as TextureDefinition,
+      // that show up without a clear context owner.  So, instead, we use the
+      // current state's state restorer.
+      if (gl::GLStateRestorer* restorer = context->GetGLStateRestorer())
+        restorer->RestoreAllExternalTextureBindingsIfNeeded();
+    }
+  }
+}
+
 void Texture::MarkLevelAsInternalWorkaround(GLenum target, GLint level) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   info.internal_workaround = true;
@@ skipping 453 matching lines @@
   UpdateMipCleared(&info, info.width, info.height,
                    gfx::Rect(info.width, info.height));
   return true;
 }
 
 void Texture::SetLevelImageInternal(GLenum target,
                                     GLint level,
                                     gl::GLImage* image,
                                     GLStreamTextureImage* stream_texture_image,
                                     ImageState state) {
+  DCHECK(!stream_texture_image || stream_texture_image == image);
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
-  info.image = image;
-  info.stream_texture_image = stream_texture_image;
+
+  if (info.image != image) {
+    info.image = image;
+    info.stream_texture_image = stream_texture_image;
+    // If |stream_texture_image| is changing we have to reset the stream texture
+    // service id if one was set. This is important because if the outgoing
+    // image owns the stream texture service id, then |service_id_| may no
+    // longer be valid after the previous image is destructed.
+    SetStreamTextureServiceId(0);
+  }
   info.image_state = state;
 
   UpdateCanRenderCondition();
   UpdateHasImages();
   UpdateEmulatingRGB();
 }
 
 void Texture::SetLevelImage(GLenum target,
                             GLint level,
                             gl::GLImage* image,
                             ImageState state) {
   SetLevelImageInternal(target, level, image, nullptr, state);
 }
 
 void Texture::SetLevelStreamTextureImage(GLenum target,
                                          GLint level,
                                          GLStreamTextureImage* image,
-                                         ImageState state) {
+                                         ImageState state,
+                                         GLuint service_id) {
   SetLevelImageInternal(target, level, image, image, state);
+  SetStreamTextureServiceId(service_id);
 }
 
 const Texture::LevelInfo* Texture::GetLevelInfo(GLint target,
                                                 GLint level) const {
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
   }
 
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
@@ skipping 91 matching lines @@
        feature_info->validators()->
            texture_sized_color_renderable_internal_format.IsValid(
                internal_format));
   bool depth_renderable = feature_info->validators()->
       texture_depth_renderable_internal_format.IsValid(internal_format);
   bool stencil_renderable = feature_info->validators()->
       texture_stencil_renderable_internal_format.IsValid(internal_format);
   return (color_renderable || depth_renderable || stencil_renderable);
 }
 
-void Texture::SetUnownedServiceId(GLuint service_id) {
-  GLuint new_service_id = service_id;
-
-  // Take no action if this isn't an OES_EXTERNAL texture.
-  if (target_ && target_ != GL_TEXTURE_EXTERNAL_OES)
-    return;
-
-  if (!service_id)
-    new_service_id = owned_service_id_;
-
-  if (service_id_ != new_service_id) {
-    service_id_ = new_service_id;
-    IncrementManagerServiceIdGeneration();
-    if (gl::GLContext* context = gl::GLContext::GetCurrent()) {
-      // It would be preferable to pass in the decoder, and ask it to do this
-      // instead.  However, there are several cases, such as TextureDefinition,
-      // that show up without a clear context owner.  So, instead, we use the
-      // current state's state restorer.
-      if (gl::GLStateRestorer* restorer = context->GetGLStateRestorer())
-        restorer->RestoreAllExternalTextureBindingsIfNeeded();
-    }
-  }
-}
-
 GLenum Texture::GetCompatibilitySwizzleForChannel(GLenum channel) {
   return GetSwizzleForChannel(channel, compatibility_swizzle_);
 }
 
 void Texture::SetCompatibilitySwizzle(const CompatibilitySwizzle* swizzle) {
   if (compatibility_swizzle_ == swizzle)
     return;
 
   compatibility_swizzle_ = swizzle;
   glTexParameteri(target_, GL_TEXTURE_SWIZZLE_R,
@@ skipping 437 matching lines @@
                                    gl::GLImage* image,
                                    Texture::ImageState state) {
   DCHECK(ref);
   ref->texture()->SetLevelImage(target, level, image, state);
 }
 
 void TextureManager::SetLevelStreamTextureImage(TextureRef* ref,
                                                 GLenum target,
                                                 GLint level,
                                                 GLStreamTextureImage* image,
-                                                Texture::ImageState state) {
+                                                Texture::ImageState state,
+                                                GLuint service_id) {
   DCHECK(ref);
-  ref->texture()->SetLevelStreamTextureImage(target, level, image, state);
+  ref->texture()->SetLevelStreamTextureImage(target, level, image, state,
+                                             service_id);
 }
 
 size_t TextureManager::GetSignatureSize() const {
   return sizeof(TextureTag) + sizeof(TextureSignature);
 }
 
 void TextureManager::AddToSignature(
     TextureRef* ref,
     GLenum target,
     GLint level,
@@ skipping 1193 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu