Allow rendering from non-stream GL_TEXTURE_EXTERNAL_OES

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 18 matching lines @@
 #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"
 
-using gpu::gles2::TextureManager;
-
 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()) {
@@ skipping 99 matching lines @@
 void GpuVideoDecodeAccelerator::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers(
           host_route_id_, requested_num_of_buffers, dimensions,
           texture_target))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers) "
                 << "failed";
   }
+  texture_dimensions_ = dimensions;
   texture_target_ = texture_target;
 }
 
 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";
@@ skipping 91 matching lines @@
   if (!video_decode_accelerator_->Initialize(profile))
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
 }
 
 // Runs on IO thread if video_decode_accelerator_->CanDecodeOnIOThread() is
 // true, otherwise on the main thread.
 void GpuVideoDecodeAccelerator::OnDecode(
     base::SharedMemoryHandle handle, int32 id, uint32 size) {
   DCHECK(video_decode_accelerator_.get());
   if (id < 0) {
-    DLOG(FATAL) << "BitstreamBuffer id " << id << " out of range";
+    DLOG(ERROR) << "BitstreamBuffer id " << id << " out of range";

[Ami GONE FROM CHROMIUM, 2013/09/25 01:09:30]

Why this change, here and elsewhere?  These are effectively DCHECKs, which have
both value as documentation and as last-defense checks on bots.

[piman, 2013/09/25 01:12:10]

This is untrusted data though, coming from the renderer? How can you assert its
values?

[Ami GONE FROM CHROMIUM, 2013/09/25 01:15:46]

For debug builds I am more concerned about asserting invariants than defending
against malicious renderers causing the browser to exit.
Do you disagree about the trade-off?

     if (child_message_loop_->BelongsToCurrentThread()) {
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
     } else {
       child_message_loop_->PostTask(
           FROM_HERE,
           base::Bind(&GpuVideoDecodeAccelerator::NotifyError,
                      base::Unretained(this),
                      media::VideoDecodeAccelerator::INVALID_ARGUMENT));
     }
     return;
   }
   video_decode_accelerator_->Decode(media::BitstreamBuffer(id, handle, size));
 }
 
 void GpuVideoDecodeAccelerator::OnAssignPictureBuffers(
-      const std::vector<int32>& buffer_ids,
-      const std::vector<uint32>& texture_ids,
-      const std::vector<gfx::Size>& sizes) {
+    const std::vector<int32>& buffer_ids,
+    const std::vector<uint32>& texture_ids) {
   DCHECK(stub_);
-  if (buffer_ids.size() != texture_ids.size() ||
-      buffer_ids.size() != sizes.size()) {
+  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;
   for (uint32 i = 0; i < buffer_ids.size(); ++i) {
     if (buffer_ids[i] < 0) {
-      DLOG(FATAL) << "Buffer id " << buffer_ids[i] << " out of range";
+      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(FATAL) << "Failed to find texture id " << texture_ids[i];
+      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(FATAL) << "Texture target mismatch for texture id "
+      DLOG(ERROR) << "Texture target mismatch for texture id "
                   << texture_ids[i];
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
-    // GL_TEXTURE_EXTERNAL_OES textures have their dimensions defined by the
-    // underlying EGLImage.
-    if (texture_target_ != GL_TEXTURE_EXTERNAL_OES) {
+    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.
+      texture_manager->SetLevelInfo(texture_ref,
+                                    GL_TEXTURE_EXTERNAL_OES,
+                                    0,
+                                    0,
+                                    texture_dimensions_.width(),
+                                    texture_dimensions_.height(),
+                                    1,
+                                    0,
+                                    0,
+                                    0,
+                                    true);
+    } else {
+      // For other targets, texture dimensions should already be defined.
       GLsizei width = 0, height = 0;
       info->GetLevelSize(texture_target_, 0, &width, &height);
-      if (width != sizes[i].width() || height != sizes[i].height()) {
-        DLOG(FATAL) << "Size mismatch for texture id " << texture_ids[i];
+      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(FATAL) << "Failed to Clear texture id " << texture_ids[i];
+      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(FATAL) << "Failed to translate texture!";
+      DLOG(ERROR) << "Failed to translate texture!";
       NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
       return;
     }
     buffers.push_back(media::PictureBuffer(
-        buffer_ids[i], sizes[i], service_texture_id));
+        buffer_ids[i], texture_dimensions_, service_texture_id));
   }
   video_decode_accelerator_->AssignPictureBuffers(buffers);
 }
 
 void GpuVideoDecodeAccelerator::OnReusePictureBuffer(
     int32 picture_buffer_id) {
   DCHECK(video_decode_accelerator_.get());
   video_decode_accelerator_->ReusePictureBuffer(picture_buffer_id);
 }
 
@@ skipping 59 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);
 }
 
 }  // namespace content