StreamTextureImages can now override a Texture's service id

media/gpu/android_deferred_rendering_backing_strategy.cc

 // Copyright 2015 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 "media/gpu/android_deferred_rendering_backing_strategy.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "base/android/build_info.h"
@@ skipping 127 matching lines @@
     const media::PictureBuffer& picture_buffer,
     const scoped_refptr<gpu::gles2::GLStreamTextureImage>& image) {
   gpu::gles2::TextureRef* texture_ref =
       state_provider_->GetTextureForPicture(picture_buffer);
   RETURN_IF_NULL(texture_ref);
 
   gpu::gles2::TextureManager* texture_manager =
       state_provider_->GetGlDecoder()->GetContextGroup()->texture_manager();
   RETURN_IF_NULL(texture_manager);
 
+  // Default to zero which will clear the stream texture service id if one was
+  // previously set.
+  GLuint stream_texture_service_id = 0;
   if (image) {
-    // Also set the parameters for the level if we're not clearing
-    // the image.
+    // Override the texture's service_id, so that it will use the one that is
+    // attached to the SurfaceTexture.
+    stream_texture_service_id = shared_state_->surface_texture_service_id();
+    DCHECK_NE(stream_texture_service_id, 0u);
+
+    // Also set the parameters for the level if we're not clearing the image.
     const gfx::Size size = state_provider_->GetSize();
     texture_manager->SetLevelInfo(texture_ref, GetTextureTarget(), 0, GL_RGBA,
                                   size.width(), size.height(), 1, 0, GL_RGBA,
                                   GL_UNSIGNED_BYTE, gfx::Rect());
 
-    // Override the texture's service_id, so that it will use the one that
-    // will be / is attached to the SurfaceTexture.
-    DCHECK(shared_state_->surface_texture_service_id());
-    texture_ref->texture()->SetUnownedServiceId(
-        shared_state_->surface_texture_service_id());
-
     static_cast<AVDACodecImage*>(image.get())
         ->set_texture(texture_ref->texture());
-  } else {
-    // Clear the unowned service_id, so that this texture is no longer going
-    // to depend on the surface texture at all.
-    texture_ref->texture()->SetUnownedServiceId(0);
   }
 
   // For SurfaceTexture we set the image to UNBOUND so that the implementation
   // will call CopyTexImage, which is where AVDACodecImage updates the
   // SurfaceTexture to the right frame.
   // For SurfaceView we set the image to be BOUND because ScheduleOverlayPlane
   // expects it. If something tries to sample from this texture it won't work,
   // but there's no way to sample from a SurfaceView anyway, so it doesn't
   // matter. The only way to use this texture is to schedule it as an overlay.
   const gpu::gles2::Texture::ImageState image_state =
       surface_texture_ ? gpu::gles2::Texture::UNBOUND
                        : gpu::gles2::Texture::BOUND;
   texture_manager->SetLevelStreamTextureImage(texture_ref, GetTextureTarget(),
-                                              0, image.get(), image_state);
+                                              0, image.get(), image_state,
+                                              stream_texture_service_id);
 }
 
 void AndroidDeferredRenderingBackingStrategy::UseCodecBufferForPictureBuffer(
     int32_t codec_buf_index,
     const media::PictureBuffer& picture_buffer) {
   // Make sure that the decoder is available.
   RETURN_IF_NULL(state_provider_->GetGlDecoder());
 
   // Notify the AVDACodecImage for picture_buffer that it should use the
   // decoded buffer codec_buf_index to render this frame.
@@ skipping 252 matching lines @@
           model.find("sm-t285") != std::string::npos ||
           model.find("sm-j320") != std::string::npos)
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace media