Reland of cc: Don't use StreamVideoDrawQuad on any platform but Android.

cc/resources/video_resource_updater_unittest.cc

 // Copyright 2013 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 "cc/resources/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 231 matching lines @@
   }
 
   WebGraphicsContext3DUploadCounter* context3d_;
   scoped_refptr<TestContextProvider> context_provider_;
   std::unique_ptr<SharedBitmapManagerAllocationCounter> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider3d_;
   std::unique_ptr<ResourceProvider> resource_provider_software_;
 };
 
 TEST_F(VideoResourceUpdaterTest, SoftwareFrame) {
+  bool use_stream_video_draw_quad = false;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, HighBitFrameNoF16) {
+  bool use_stream_video_draw_quad = false;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
 }
 
 class VideoResourceUpdaterTestWithF16 : public VideoResourceUpdaterTest {
  public:
   VideoResourceUpdaterTestWithF16() : VideoResourceUpdaterTest() {
     context3d_->set_support_texture_half_float_linear(true);
   }
 };
 
 TEST_F(VideoResourceUpdaterTestWithF16, HighBitFrame) {
+  bool use_stream_video_draw_quad = false;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_NEAR(resources.multiplier, 2.0, 0.1);
   EXPECT_NEAR(resources.offset, 0.5, 0.1);
 
   // Create the resource again, to test the path where the
   // resources are cached.
   VideoFrameExternalResources resources2 =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources2.type);
   EXPECT_NEAR(resources2.multiplier, 2.0, 0.1);
   EXPECT_NEAR(resources2.offset, 0.5, 0.1);
 }
 
 TEST_F(VideoResourceUpdaterTest, HighBitFrameSoftwareCompositor) {
-  VideoResourceUpdater updater(nullptr, resource_provider_software_.get());
+  bool use_stream_video_draw_quad = false;
+  VideoResourceUpdater updater(nullptr, resource_provider_software_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrame) {
+  bool use_stream_video_draw_quad = false;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrameSoftwareCompositor) {
-  VideoResourceUpdater updater(nullptr, resource_provider_software_.get());
+  bool use_stream_video_draw_quad = false;
+  VideoResourceUpdater updater(nullptr, resource_provider_software_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, ReuseResource) {
+  bool use_stream_video_draw_quad = false;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
   video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
 
   // Allocate the resources for a YUV video frame.
   context3d_->ResetUploadCount();
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_EQ(size_t(3), resources.mailboxes.size());
   EXPECT_EQ(size_t(3), resources.release_callbacks.size());
@@ skipping 10 matching lines @@
   context3d_->ResetUploadCount();
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_EQ(size_t(3), resources.mailboxes.size());
   EXPECT_EQ(size_t(3), resources.release_callbacks.size());
   // The data should be reused so expect no texture uploads.
   EXPECT_EQ(0, context3d_->UploadCount());
 }
 
 TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDelete) {
+  bool use_stream_video_draw_quad = false;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
   video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
 
   // Allocate the resources for a YUV video frame.
   context3d_->ResetUploadCount();
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_EQ(size_t(3), resources.mailboxes.size());
   EXPECT_EQ(size_t(3), resources.release_callbacks.size());
   EXPECT_EQ(size_t(0), resources.software_resources.size());
   // Expect exactly three texture uploads, one for each plane.
   EXPECT_EQ(3, context3d_->UploadCount());
 
   // Allocate resources for the same frame.
   context3d_->ResetUploadCount();
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_EQ(size_t(3), resources.mailboxes.size());
   EXPECT_EQ(size_t(3), resources.release_callbacks.size());
   // The data should be reused so expect no texture uploads.
   EXPECT_EQ(0, context3d_->UploadCount());
 }
 
 TEST_F(VideoResourceUpdaterTest, SoftwareFrameSoftwareCompositor) {
-  VideoResourceUpdater updater(nullptr, resource_provider_software_.get());
+  bool use_stream_video_draw_quad = false;
+  VideoResourceUpdater updater(nullptr, resource_provider_software_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, ReuseResourceSoftwareCompositor) {
-  VideoResourceUpdater updater(nullptr, resource_provider_software_.get());
+  bool use_stream_video_draw_quad = false;
+  VideoResourceUpdater updater(nullptr, resource_provider_software_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
   video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
 
   // Allocate the resources for a software video frame.
   shared_bitmap_manager_->ResetAllocationCount();
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
   EXPECT_EQ(size_t(0), resources.mailboxes.size());
   EXPECT_EQ(size_t(0), resources.release_callbacks.size());
@@ skipping 10 matching lines @@
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
   EXPECT_EQ(size_t(0), resources.mailboxes.size());
   EXPECT_EQ(size_t(0), resources.release_callbacks.size());
   EXPECT_EQ(size_t(1), resources.software_resources.size());
   // The data should be reused so expect no new allocations.
   EXPECT_EQ(0, shared_bitmap_manager_->AllocationCount());
 }
 
 TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDeleteSoftwareCompositor) {
-  VideoResourceUpdater updater(nullptr, resource_provider_software_.get());
+  bool use_stream_video_draw_quad = false;
+  VideoResourceUpdater updater(nullptr, resource_provider_software_.get(),
+                               use_stream_video_draw_quad);
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
   video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
 
   // Allocate the resources for a software video frame.
   shared_bitmap_manager_->ResetAllocationCount();
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
   EXPECT_EQ(size_t(0), resources.mailboxes.size());
   EXPECT_EQ(size_t(0), resources.release_callbacks.size());
   EXPECT_EQ(size_t(1), resources.software_resources.size());
   // Expect exactly one allocated shared bitmap.
   EXPECT_EQ(1, shared_bitmap_manager_->AllocationCount());
 
   // Allocate resources for the same frame.
   shared_bitmap_manager_->ResetAllocationCount();
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
   EXPECT_EQ(size_t(0), resources.mailboxes.size());
   EXPECT_EQ(size_t(0), resources.release_callbacks.size());
   EXPECT_EQ(size_t(1), resources.software_resources.size());
   // The data should be reused so expect no new allocations.
   EXPECT_EQ(0, shared_bitmap_manager_->AllocationCount());
 }
 
 TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes) {
+  bool use_stream_video_draw_quad = false;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
 
   scoped_refptr<media::VideoFrame> video_frame =
       CreateTestRGBAHardwareVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE,
             resources.type);
   EXPECT_EQ(1u, resources.mailboxes.size());
   EXPECT_EQ(1u, resources.release_callbacks.size());
@@ skipping 10 matching lines @@
 
   video_frame = CreateTestYuvHardwareVideoFrame();
   video_frame->metadata()->SetBoolean(
       media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED, true);
 
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_TRUE(resources.read_lock_fences_enabled);
 }
 
 TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_StreamTexture) {
+  bool use_stream_video_draw_quad = true;
   VideoResourceUpdater updater(context_provider_.get(),
-                               resource_provider3d_.get());
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
   context3d_->ResetTextureCreationCount();
   scoped_refptr<media::VideoFrame> video_frame =
       CreateTestStreamTextureHardwareVideoFrame(false);
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE,
             resources.type);
   EXPECT_EQ(1u, resources.mailboxes.size());
   EXPECT_EQ((GLenum)GL_TEXTURE_EXTERNAL_OES, resources.mailboxes[0].target());
   EXPECT_EQ(1u, resources.release_callbacks.size());
   EXPECT_EQ(0u, resources.software_resources.size());
   EXPECT_EQ(0, context3d_->TextureCreationCount());
 
   // A copied stream texture should return an RGBA resource in a new
   // GL_TEXTURE_2D texture.
   context3d_->ResetTextureCreationCount();
   video_frame = CreateTestStreamTextureHardwareVideoFrame(true);
   context3d_->ResetImmutableTextureCreated();
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
-  EXPECT_EQ(VideoFrameExternalResources::RGBA_RESOURCE, resources.type);
+  EXPECT_EQ(VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE,
+            resources.type);
   EXPECT_EQ(1u, resources.mailboxes.size());
   EXPECT_EQ((GLenum)GL_TEXTURE_2D, resources.mailboxes[0].target());
   EXPECT_EQ(1u, resources.release_callbacks.size());
   EXPECT_EQ(0u, resources.software_resources.size());
   EXPECT_EQ(1, context3d_->TextureCreationCount());
 
   // The texture copy path requires the use of CopyTextureCHROMIUM, which
   // enforces that the target texture not be immutable, as it may need
   // to alter the storage of the texture. Therefore, this test asserts
   // that an immutable texture wasn't created by glTexStorage2DEXT, when
   // that extension is supported.
   EXPECT_FALSE(context3d_->WasImmutableTextureCreated());
 }
 
+TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_TextureQuad) {
+  bool use_stream_video_draw_quad = false;
+  VideoResourceUpdater updater(context_provider_.get(),
+                               resource_provider3d_.get(),
+                               use_stream_video_draw_quad);
+  context3d_->ResetTextureCreationCount();
+  scoped_refptr<media::VideoFrame> video_frame =
+      CreateTestStreamTextureHardwareVideoFrame(false);
+
+  VideoFrameExternalResources resources =
+      updater.CreateExternalResourcesFromVideoFrame(video_frame);
+  EXPECT_EQ(VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE,
+            resources.type);
+  EXPECT_EQ(1u, resources.mailboxes.size());
+  EXPECT_EQ((GLenum)GL_TEXTURE_EXTERNAL_OES, resources.mailboxes[0].target());
+  EXPECT_EQ(1u, resources.release_callbacks.size());
+  EXPECT_EQ(0u, resources.software_resources.size());
+  EXPECT_EQ(0, context3d_->TextureCreationCount());
+}
+
 }  // namespace
 }  // namespace cc