Set the texture to cleared in VideoDecodeAccelerator::PictureReady.

content/common/gpu/media/gpu_video_decode_accelerator.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 "content/common/gpu/media/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 16 matching lines @@
 #include "content/common/gpu/media/dxva_video_decode_accelerator.h"
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
 #include "content/common/gpu/media/exynos_video_decode_accelerator.h"
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
 #include "ui/gl/gl_context_glx.h"
 #include "content/common/gpu/media/vaapi_video_decode_accelerator.h"
 #elif defined(OS_ANDROID)
 #include "content/common/gpu/media/android_video_decode_accelerator.h"
 #endif
 
-#include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gfx/size.h"
 
 namespace content {
 
 static bool MakeDecoderContextCurrent(
     const base::WeakPtr<GpuCommandBufferStub> stub) {
   if (!stub.get()) {
     DLOG(ERROR) << "Stub is gone; won't MakeCurrent().";
     return false;
   }
 
   if (!stub->decoder()->MakeCurrent()) {
     DLOG(ERROR) << "Failed to MakeCurrent()";
     return false;
   }
 
   return true;
 }
 
+// A helper class that works like AutoLock but only acquires the lock when
+// DCHECK is on.
+class DebugAutoLock {
+ public:
+  explicit DebugAutoLock(base::Lock& lock) : lock_(lock) {
+    if (DCHECK_IS_ON())
+      lock_.Acquire();
+  }
+
+  ~DebugAutoLock() {
+    if (DCHECK_IS_ON()) {
+      lock_.AssertAcquired();
+      lock_.Release();
+    }
+  }
+
+ private:
+  base::Lock& lock_;
+  DISALLOW_COPY_AND_ASSIGN(DebugAutoLock);
+};
+
 class GpuVideoDecodeAccelerator::MessageFilter
     : public IPC::ChannelProxy::MessageFilter {
  public:
   MessageFilter(GpuVideoDecodeAccelerator* owner, int32 host_route_id)
       : owner_(owner), host_route_id_(host_route_id) {}
 
   virtual void OnChannelError() OVERRIDE { channel_ = NULL; }
 
   virtual void OnChannelClosing() OVERRIDE { channel_ = NULL; }
 
@@ skipping 102 matching lines @@
 }
 
 void GpuVideoDecodeAccelerator::DismissPictureBuffer(
     int32 picture_buffer_id) {
   // Notify client that picture buffer is now unused.
   if (!Send(new AcceleratedVideoDecoderHostMsg_DismissPictureBuffer(
           host_route_id_, picture_buffer_id))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_DismissPictureBuffer) "
                 << "failed";
   }
+  DebugAutoLock auto_lock(lock_);
+  uncleared_textures_.erase(picture_buffer_id);
 }
 
 void GpuVideoDecodeAccelerator::PictureReady(
     const media::Picture& picture) {
+  // VDA may call PictureReady on IO thread. SetTextureCleared should run on
+  // the child thread. VDA is responsible to call PictureReady on the child
+  // thread when a picture buffer is delivered the first time.
+  if (child_message_loop_->BelongsToCurrentThread()) {
+    if (!SetTextureCleared(picture))
+      return;
+  } else {
+    DCHECK(io_message_loop_->BelongsToCurrentThread());
+    if (DCHECK_IS_ON()) {
+      DebugAutoLock auto_lock(lock_);
+      DCHECK_EQ(0u, uncleared_textures_.count(picture.picture_buffer_id()));
+    }
+  }
+
   if (!Send(new AcceleratedVideoDecoderHostMsg_PictureReady(
           host_route_id_,
           picture.picture_buffer_id(),
           picture.bitstream_buffer_id()))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_PictureReady) failed";
   }
 }
 
 void GpuVideoDecodeAccelerator::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
@@ skipping 105 matching lines @@
   if (buffer_ids.size() != texture_ids.size()) {
     NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
     return;
   }
 
   gpu::gles2::GLES2Decoder* command_decoder = stub_->decoder();
   gpu::gles2::TextureManager* texture_manager =
       command_decoder->GetContextGroup()->texture_manager();
 
   std::vector<media::PictureBuffer> buffers;
+  std::vector<scoped_refptr<gpu::gles2::TextureRef> > textures;
   for (uint32 i = 0; i < buffer_ids.size(); ++i) {
     if (buffer_ids[i] < 0) {
       DLOG(ERROR) << "Buffer id " << buffer_ids[i] << " out of range";
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
     gpu::gles2::TextureRef* texture_ref = texture_manager->GetTexture(
         texture_ids[i]);
     if (!texture_ref) {
       DLOG(ERROR) << "Failed to find texture id " << texture_ids[i];
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
     gpu::gles2::Texture* info = texture_ref->texture();
     if (info->target() != texture_target_) {
       DLOG(ERROR) << "Texture target mismatch for texture id "
                   << texture_ids[i];
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
     if (texture_target_ == GL_TEXTURE_EXTERNAL_OES) {
       // GL_TEXTURE_EXTERNAL_OES textures have their dimensions defined by the
-      // underlying EGLImage.  Use |texture_dimensions_| for this size.  The
-      // textures cannot be rendered to or cleared, so we set |cleared| true to
-      // skip clearing.
+      // underlying EGLImage.  Use |texture_dimensions_| for this size.
       texture_manager->SetLevelInfo(texture_ref,
                                     GL_TEXTURE_EXTERNAL_OES,
                                     0,
                                     0,
                                     texture_dimensions_.width(),
                                     texture_dimensions_.height(),
                                     1,
                                     0,
                                     0,
                                     0,
-                                    true);
+                                    false);
     } else {
       // For other targets, texture dimensions should already be defined.
       GLsizei width = 0, height = 0;
       info->GetLevelSize(texture_target_, 0, &width, &height);
       if (width != texture_dimensions_.width() ||
           height != texture_dimensions_.height()) {
         DLOG(ERROR) << "Size mismatch for texture id " << texture_ids[i];
         NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
         return;
       }
     }
-    if (!texture_manager->ClearRenderableLevels(command_decoder, texture_ref)) {
-      DLOG(ERROR) << "Failed to Clear texture id " << texture_ids[i];
-      NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
-      return;
-    }
     uint32 service_texture_id;
     if (!command_decoder->GetServiceTextureId(
             texture_ids[i], &service_texture_id)) {
       DLOG(ERROR) << "Failed to translate texture!";
       NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
       return;
     }
     buffers.push_back(media::PictureBuffer(
         buffer_ids[i], texture_dimensions_, service_texture_id));
+    textures.push_back(texture_ref);
   }
   video_decode_accelerator_->AssignPictureBuffers(buffers);
+  DebugAutoLock auto_lock(lock_);
+  for (uint32 i = 0; i < buffer_ids.size(); ++i)
+    uncleared_textures_[buffer_ids[i]] = textures[i];
 }
 
 void GpuVideoDecodeAccelerator::OnReusePictureBuffer(
     int32 picture_buffer_id) {
   DCHECK(video_decode_accelerator_.get());
   video_decode_accelerator_->ReusePictureBuffer(picture_buffer_id);
 }
 
 void GpuVideoDecodeAccelerator::OnFlush() {
   DCHECK(video_decode_accelerator_.get());
@@ skipping 58 matching lines @@
 }
 
 bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
   DCHECK(stub_);
   if (filter_.get() && io_message_loop_->BelongsToCurrentThread())
     return filter_->SendOnIOThread(message);
   DCHECK(child_message_loop_->BelongsToCurrentThread());
   return stub_->channel()->Send(message);
 }
 
+bool GpuVideoDecodeAccelerator::SetTextureCleared(
+    const media::Picture& picture) {
+  DCHECK(child_message_loop_->BelongsToCurrentThread());
+  DebugAutoLock auto_lock(lock_);
+  std::map<int32, scoped_refptr<gpu::gles2::TextureRef> >::iterator it;
+  it = uncleared_textures_.find(picture.picture_buffer_id());
+  if (it == uncleared_textures_.end())
+    return true;

[Ami GONE FROM CHROMIUM, 2013/09/30 18:03:03]

NOTREACHED?

[Ami GONE FROM CHROMIUM, 2013/09/30 18:03:03]

return false?
(as it is, this function always returns true, so might as well return void)

[wuchengli, 2013/10/01 03:49:43]

Done. Changed to return void.

+
+  scoped_refptr<gpu::gles2::TextureRef> texture_ref = it->second;
+  GLenum target = texture_ref->texture()->target();
+  gpu::gles2::TextureManager* texture_manager =
+      stub_->decoder()->GetContextGroup()->texture_manager();
+  texture_manager->SetLevelCleared(texture_ref, target, 0, true);
+  uncleared_textures_.erase(it);
+  return true;
+}
+
 }  // namespace content