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 1459 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;

[liberato (no reviews please), 2016/06/02 14:37:02]

wow -- this was fragile before, and i just realized how bad it was.  this kept
setting and resetting the stream texture during normal drawing. DoCopyTexImage
-> SetLevelImage -> here with |stream_texture_image| == nullptr, then
avda_codec_image (hopefully) gets far enough in CopyTexImage to re-set it
properly.  that would leave the stream texture unset if CopyTexImage was called
on an early-out case, such as CopyTextureCHROMIUM.

i think that it would get back to normal on the next browser compositor frame,
but the texture matrix wouldn't be set properly until it was.  that happens
before the associated CopyTexImage, so one frame would be wrong at least, i
think.

yay for if() :)

+
+  if (info.image != image) {

[liberato (no reviews please), 2016/06/02 14:37:02]

please update the tests (texture_manager_unittest.cc) for the new names, and
include a to check for this case, and the new parameter in
setLeveStreamTextureImage.  there are already tests for the unowned service id
to base it on.

[watk, 2016/06/03 01:09:46]

Done.

+    info.image = image;
+    info.stream_texture_image = stream_texture_image;
+    // If |image| is different, then |stream_texture_image| must also be
+    // different, so clear the stream texture service id because it's no longer

[liberato (no reviews please), 2016/06/02 14:37:02]

nit: the comment is a little misleading.  we don't know that it's no longer
valid.  it's because the stream texture manages the lifetime of the service id,
and we can't guarantee that it's still valid.  the extra context might be
helpful just so folks realize that it's a security thing.

[watk, 2016/06/03 01:09:46]

Done.

+    // valid.
+    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) {
+void Texture::SetStreamTextureServiceId(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) {
@@ skipping 460 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