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

VideoLayerImpl is appending StreamVideoDrawQuads on CrOS.

StreamVideoDrawQuads should be used on Android since almost all its
features are supported by TextureDrawQuad.
The only difference is that StreamVideoDrawQuad calls
glUniformMatrix4fvStreamTextureMatrixCHROMIUM before drawing, that
just sets a uniform matrix on CrOS.

This CL makes sure VideoLayerImpl produces StreamVideoDrawQuads only
on Android.

BUG=702750
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_trusty_blink_rel

Review-Url: https://codereview.chromium.org/2763223003
Cr-Commit-Position: refs/heads/master@{#460547}

cc/layers/video_layer_impl.cc

@@ -101,9 +101,10 @@ bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
     return false;
 
   if (!updater_) {
-    updater_.reset(
-        new VideoResourceUpdater(layer_tree_impl()->context_provider(),
-                                 layer_tree_impl()->resource_provider()));
+    updater_.reset(new VideoResourceUpdater(
+        layer_tree_impl()->context_provider(),
+        layer_tree_impl()->resource_provider(),
+        layer_tree_impl()->settings().use_stream_video_draw_quad));
   }
 
   VideoFrameExternalResources external_resources =

cc/output/renderer_pixeltest.cc

@@ -915,12 +915,13 @@ class IntersectingQuadGLPixelTest
  public:
   void SetUp() override {
     IntersectingQuadPixelTest<TypeParam>::SetUp();
-    video_resource_updater_.reset(
-        new VideoResourceUpdater(this->output_surface_->context_provider(),
-                                 this->resource_provider_.get()));
-    video_resource_updater2_.reset(
-        new VideoResourceUpdater(this->output_surface_->context_provider(),
-                                 this->resource_provider_.get()));
+    bool use_stream_video_draw_quad = false;
+    video_resource_updater_.reset(new VideoResourceUpdater(
+        this->output_surface_->context_provider(),
+        this->resource_provider_.get(), use_stream_video_draw_quad));
+    video_resource_updater2_.reset(new VideoResourceUpdater(
+        this->output_surface_->context_provider(),
+        this->resource_provider_.get(), use_stream_video_draw_quad));
   }
 
  protected:
@@ -1241,8 +1242,10 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
 
   void SetUp() override {
     GLRendererPixelTest::SetUp();
+    bool use_stream_video_draw_quad = false;
     video_resource_updater_.reset(new VideoResourceUpdater(
-        output_surface_->context_provider(), resource_provider_.get()));
+        output_surface_->context_provider(), resource_provider_.get(),
+        use_stream_video_draw_quad));
   }
 
   std::unique_ptr<VideoResourceUpdater> video_resource_updater_;

cc/resources/video_resource_updater.cc

@@ -35,7 +35,8 @@ namespace {
 const ResourceFormat kRGBResourceFormat = RGBA_8888;
 
 VideoFrameExternalResources::ResourceType ResourceTypeForVideoFrame(
-    media::VideoFrame* video_frame) {
+    media::VideoFrame* video_frame,
+    bool use_stream_video_draw_quad) {
   switch (video_frame->format()) {
     case media::PIXEL_FORMAT_ARGB:
     case media::PIXEL_FORMAT_XRGB:
@@ -46,10 +47,11 @@ VideoFrameExternalResources::ResourceType ResourceTypeForVideoFrame(
                      ? VideoFrameExternalResources::RGB_RESOURCE
                      : VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE;
         case GL_TEXTURE_EXTERNAL_OES:
-          return video_frame->metadata()->IsTrue(
-                     media::VideoFrameMetadata::COPY_REQUIRED)
-                     ? VideoFrameExternalResources::RGBA_RESOURCE
-                     : VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE;
+          if (use_stream_video_draw_quad &&
+              !video_frame->metadata()->IsTrue(
+                  media::VideoFrameMetadata::COPY_REQUIRED))
+            return VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE;
+          return VideoFrameExternalResources::RGBA_RESOURCE;
         case GL_TEXTURE_RECTANGLE_ARB:
           return VideoFrameExternalResources::RGB_RESOURCE;
         default:
@@ -172,10 +174,11 @@ VideoFrameExternalResources::VideoFrameExternalResources(
 VideoFrameExternalResources::~VideoFrameExternalResources() {}
 
 VideoResourceUpdater::VideoResourceUpdater(ContextProvider* context_provider,
-                                           ResourceProvider* resource_provider)
+                                           ResourceProvider* resource_provider,
+                                           bool use_stream_video_draw_quad)
     : context_provider_(context_provider),
-      resource_provider_(resource_provider) {
-}
+      resource_provider_(resource_provider),
+      use_stream_video_draw_quad_(use_stream_video_draw_quad) {}
 
 VideoResourceUpdater::~VideoResourceUpdater() {
   for (const PlaneResource& plane_resource : all_resources_)
@@ -626,7 +629,8 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
   }
   gfx::ColorSpace resource_color_space = video_frame->ColorSpace();
 
-  external_resources.type = ResourceTypeForVideoFrame(video_frame.get());
+  external_resources.type =
+      ResourceTypeForVideoFrame(video_frame.get(), use_stream_video_draw_quad_);
   if (external_resources.type == VideoFrameExternalResources::NONE) {
     DLOG(ERROR) << "Unsupported Texture format"
                 << media::VideoPixelFormatToString(video_frame->format());

cc/resources/video_resource_updater.h

@@ -74,7 +74,8 @@ class CC_EXPORT VideoResourceUpdater
     : public base::SupportsWeakPtr<VideoResourceUpdater> {
  public:
   VideoResourceUpdater(ContextProvider* context_provider,
-                       ResourceProvider* resource_provider);
+                       ResourceProvider* resource_provider,
+                       bool use_stream_video_draw_quad);
   ~VideoResourceUpdater();
 
   VideoFrameExternalResources CreateExternalResourcesFromVideoFrame(
@@ -176,6 +177,7 @@ class CC_EXPORT VideoResourceUpdater
 
   ContextProvider* context_provider_;
   ResourceProvider* resource_provider_;
+  const bool use_stream_video_draw_quad_;
   std::unique_ptr<media::SkCanvasVideoRenderer> video_renderer_;
   std::vector<uint8_t> upload_pixels_;
 

cc/resources/video_resource_updater_unittest.cc

@@ -249,8 +249,10 @@ class VideoResourceUpdaterTest : public testing::Test {
 };
 
 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 =
@@ -259,8 +261,10 @@ TEST_F(VideoResourceUpdaterTest, SoftwareFrame) {
 }
 
 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 =
@@ -276,8 +280,10 @@ class VideoResourceUpdaterTestWithF16 : public VideoResourceUpdaterTest {
 };
 
 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 =
@@ -296,7 +302,9 @@ TEST_F(VideoResourceUpdaterTestWithF16, HighBitFrame) {
 }
 
 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 =
@@ -305,8 +313,10 @@ TEST_F(VideoResourceUpdaterTest, HighBitFrameSoftwareCompositor) {
 }
 
 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 =
@@ -315,7 +325,9 @@ TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrame) {
 }
 
 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 =
@@ -324,8 +336,10 @@ TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrameSoftwareCompositor) {
 }
 
 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));
 
@@ -356,8 +370,10 @@ TEST_F(VideoResourceUpdaterTest, ReuseResource) {
 }
 
 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));
 
@@ -383,7 +399,9 @@ TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDelete) {
 }
 
 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 =
@@ -392,7 +410,9 @@ TEST_F(VideoResourceUpdaterTest, SoftwareFrameSoftwareCompositor) {
 }
 
 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));
 
@@ -423,7 +443,9 @@ TEST_F(VideoResourceUpdaterTest, ReuseResourceSoftwareCompositor) {
 }
 
 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));
 
@@ -450,8 +472,10 @@ TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDeleteSoftwareCompositor) {
 }
 
 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();
@@ -482,8 +506,10 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes) {
 }
 
 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);
@@ -519,5 +545,24 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_StreamTexture) {
   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_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

cc/trees/layer_tree_settings.h

@@ -42,6 +42,7 @@ class CC_EXPORT LayerTreeSettings {
   int gpu_rasterization_msaa_sample_count = 0;
   float gpu_rasterization_skewport_target_time_in_seconds = 0.2f;
   bool create_low_res_tiling = false;
+  bool use_stream_video_draw_quad = false;
 
   enum ScrollbarAnimator {
     NO_ANIMATOR,

content/renderer/gpu/render_widget_compositor.cc

@@ -383,6 +383,7 @@ cc::LayerTreeSettings RenderWidgetCompositor::GenerateLayerTreeSettings(
   bool using_synchronous_compositor =
       GetContentClient()->UsingSynchronousCompositing();
 
+  settings.use_stream_video_draw_quad = true;
   settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
   if (using_synchronous_compositor) {
     // Android WebView uses system scrollbars, so make ours invisible.