Revert of Reland "Fix HTML5 video blurry"

cc/output/renderer_pixeltest.cc

 // Copyright 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 <stddef.h>
 #include <stdint.h>
 #include <memory>
 
 #include "base/message_loop/message_loop.h"
-#include "base/strings/string_split.h"
 #include "cc/base/math_util.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/video_resource_updater.h"
 #include "cc/test/fake_raster_source.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/pixel_test.h"
-#include "cc/test/test_in_process_context_provider.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/video_frame.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ skipping 181 matching lines @@
   gfx::ColorSpace video_color_space = video_frame->ColorSpace();
 
   const gfx::Rect opaque_rect(0, 0, 0, 0);
 
   if (with_alpha) {
     memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value,
            video_frame->stride(media::VideoFrame::kAPlane) *
                video_frame->rows(media::VideoFrame::kAPlane));
   }
 
-  VideoFrameExternalResources external_resources =
+  VideoFrameExternalResources resources =
       video_resource_updater->CreateExternalResourcesFromVideoFrame(
           video_frame);
 
-  ResourceProvider::ResourceIdArray resource_ids;
-  resource_ids.reserve(external_resources.mailboxes.size());
-  for (size_t i = 0; i < external_resources.mailboxes.size(); ++i) {
-    ResourceId resource_id =
-        resource_provider->CreateResourceFromTextureMailbox(
-            external_resources.mailboxes[i],
-            SingleReleaseCallbackImpl::Create(
-                external_resources.release_callbacks[i]),
-            external_resources.read_lock_fences_enabled);
-    resource_ids.push_back(resource_id);
+  EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
+  EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
+            resources.mailboxes.size());
+  EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
+            resources.release_callbacks.size());
+
+  ResourceId y_resource = resource_provider->CreateResourceFromTextureMailbox(
+      resources.mailboxes[media::VideoFrame::kYPlane],
+      SingleReleaseCallbackImpl::Create(
+          resources.release_callbacks[media::VideoFrame::kYPlane]));
+  ResourceId u_resource = resource_provider->CreateResourceFromTextureMailbox(
+      resources.mailboxes[media::VideoFrame::kUPlane],
+      SingleReleaseCallbackImpl::Create(
+          resources.release_callbacks[media::VideoFrame::kUPlane]));
+  ResourceId v_resource = resource_provider->CreateResourceFromTextureMailbox(
+      resources.mailboxes[media::VideoFrame::kVPlane],
+      SingleReleaseCallbackImpl::Create(
+          resources.release_callbacks[media::VideoFrame::kVPlane]));
+  ResourceId a_resource = 0;
+  if (with_alpha) {
+    a_resource = resource_provider->CreateResourceFromTextureMailbox(
+        resources.mailboxes[media::VideoFrame::kAPlane],
+        SingleReleaseCallbackImpl::Create(
+            resources.release_callbacks[media::VideoFrame::kAPlane]));
   }
 
-  switch (external_resources.type) {
-    case VideoFrameExternalResources::YUV_RESOURCE: {
-      EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-                external_resources.mailboxes.size());
-      EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-                external_resources.release_callbacks.size());
-      const gfx::Size ya_tex_size = video_frame->coded_size();
-      const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize(
-          video_frame->format(), media::VideoFrame::kUPlane,
-          video_frame->coded_size());
-      DCHECK(uv_tex_size ==
-             media::VideoFrame::PlaneSize(video_frame->format(),
-                                          media::VideoFrame::kVPlane,
-                                          video_frame->coded_size()));
-      if (with_alpha) {
-        DCHECK(ya_tex_size ==
-               media::VideoFrame::PlaneSize(video_frame->format(),
-                                            media::VideoFrame::kAPlane,
-                                            video_frame->coded_size()));
-      }
-      gfx::RectF ya_tex_coord_rect(
-          tex_coord_rect.x() * ya_tex_size.width(),
-          tex_coord_rect.y() * ya_tex_size.height(),
-          tex_coord_rect.width() * ya_tex_size.width(),
-          tex_coord_rect.height() * ya_tex_size.height());
-      gfx::RectF uv_tex_coord_rect(
-          tex_coord_rect.x() * uv_tex_size.width(),
-          tex_coord_rect.y() * uv_tex_size.height(),
-          tex_coord_rect.width() * uv_tex_size.width(),
-          tex_coord_rect.height() * uv_tex_size.height());
+  const gfx::Size ya_tex_size = video_frame->coded_size();
+  const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize(
+      video_frame->format(), media::VideoFrame::kUPlane,
+      video_frame->coded_size());
+  DCHECK(uv_tex_size == media::VideoFrame::PlaneSize(
+                            video_frame->format(), media::VideoFrame::kVPlane,
+                            video_frame->coded_size()));
+  if (with_alpha) {
+    DCHECK(ya_tex_size == media::VideoFrame::PlaneSize(
+                              video_frame->format(), media::VideoFrame::kAPlane,
+                              video_frame->coded_size()));
+  }
 
-      YUVVideoDrawQuad* yuv_quad =
-          render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
-      yuv_quad->SetNew(
-          shared_state, rect, opaque_rect, visible_rect, ya_tex_coord_rect,
-          uv_tex_coord_rect, ya_tex_size, uv_tex_size, resource_ids[0],
-          resource_ids[1],
-          resource_ids.size() > 2 ? resource_ids[2] : resource_ids[1],
-          resource_ids.size() > 3 ? resource_ids[3] : 0, color_space,
-          video_color_space, external_resources.offset,
-          external_resources.multiplier, external_resources.bits_per_channel);
-      break;
-    }
-    case VideoFrameExternalResources::RGBA_RESOURCE: {
-      EXPECT_EQ(1u, external_resources.mailboxes.size());
-      EXPECT_EQ(1u, external_resources.release_callbacks.size());
-      float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-      TextureDrawQuad* texture_quad =
-          render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
-      texture_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
-                           resource_ids[0], false, tex_coord_rect.origin(),
-                           tex_coord_rect.bottom_right(), SK_ColorTRANSPARENT,
-                           opacity, false, false, false);
-      break;
-    }
-    case VideoFrameExternalResources::NONE:
-    case VideoFrameExternalResources::RGB_RESOURCE:
-    case VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE:
-    case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE:
-    case VideoFrameExternalResources::SOFTWARE_RESOURCE:
-      NOTREACHED();
-      break;
+  gfx::RectF ya_tex_coord_rect(tex_coord_rect.x() * ya_tex_size.width(),
+                               tex_coord_rect.y() * ya_tex_size.height(),
+                               tex_coord_rect.width() * ya_tex_size.width(),
+                               tex_coord_rect.height() * ya_tex_size.height());
+  gfx::RectF uv_tex_coord_rect(tex_coord_rect.x() * uv_tex_size.width(),
+                               tex_coord_rect.y() * uv_tex_size.height(),
+                               tex_coord_rect.width() * uv_tex_size.width(),
+                               tex_coord_rect.height() * uv_tex_size.height());
+
+  YUVVideoDrawQuad* yuv_quad =
+      render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
+  uint32_t bits_per_channel = 8;
+  if (video_frame->format() == media::PIXEL_FORMAT_YUV420P10 ||
+      video_frame->format() == media::PIXEL_FORMAT_YUV422P10 ||
+      video_frame->format() == media::PIXEL_FORMAT_YUV444P10) {
+    bits_per_channel = 10;
   }
+
+  yuv_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
+                   ya_tex_coord_rect, uv_tex_coord_rect, ya_tex_size,
+                   uv_tex_size, y_resource, u_resource, v_resource, a_resource,
+                   color_space, video_color_space, 0.0f, 1.0f,
+                   bits_per_channel);
 }
 
 void CreateTestY16TextureDrawQuad_FromVideoFrame(
     const SharedQuadState* shared_state,
     scoped_refptr<media::VideoFrame> video_frame,
     const gfx::RectF& tex_coord_rect,
     RenderPass* render_pass,
     VideoResourceUpdater* video_resource_updater,
     const gfx::Rect& rect,
     const gfx::Rect& visible_rect,
     ResourceProvider* resource_provider) {
   VideoFrameExternalResources resources =
       video_resource_updater->CreateExternalResourcesFromVideoFrame(
           video_frame);
 
   EXPECT_EQ(VideoFrameExternalResources::RGBA_RESOURCE, resources.type);
   EXPECT_EQ(1u, resources.mailboxes.size());
   EXPECT_EQ(1u, resources.release_callbacks.size());
 
   ResourceId y_resource = resource_provider->CreateResourceFromTextureMailbox(
       resources.mailboxes[0],
       SingleReleaseCallbackImpl::Create(resources.release_callbacks[0]));
 
   TextureDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
-  quad->SetNew(shared_state, rect, gfx::Rect(), visible_rect, y_resource, false,
+  quad->SetNew(shared_state, rect, gfx::Rect(), rect, y_resource, false,
                tex_coord_rect.origin(), tex_coord_rect.bottom_right(),
                SK_ColorBLACK, vertex_opacity, false, false, false);
 }
 
 // Upshift video frame to 10 bit.
 scoped_refptr<media::VideoFrame> CreateHighbitVideoFrame(
     media::VideoFrame* video_frame) {
   media::VideoPixelFormat format;
   switch (video_frame->format()) {
     case media::PIXEL_FORMAT_I420:
@@ skipping 42 matching lines @@
     bool is_transparent,
     bool highbit,
     const gfx::RectF& tex_coord_rect,
     RenderPass* render_pass,
     VideoResourceUpdater* video_resource_updater,
     const gfx::Rect& rect,
     const gfx::Rect& visible_rect,
     ResourceProvider* resource_provider) {
   scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
       format, rect.size(), rect, rect.size(), base::TimeDelta());
-  video_frame->metadata()->SetInteger(media::VideoFrameMetadata::COLOR_SPACE,
-                                      media::COLOR_SPACE_JPEG);
 
   // YUV values representing a striped pattern, for validating texture
   // coordinates for sampling.
   uint8_t y_value = 0;
   uint8_t u_value = 0;
   uint8_t v_value = 0;
   for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) {
     uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) +
                      video_frame->stride(media::VideoFrame::kYPlane) * i;
     for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane);
@@ skipping 123 matching lines @@
 
   uint8_t alpha_value = is_transparent ? 0 : 128;
   CreateTestYUVVideoDrawQuad_FromVideoFrame(
       shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
       video_resource_updater, rect, visible_rect, resource_provider);
 }
 
 void CreateTestYUVVideoDrawQuad_NV12(const SharedQuadState* shared_state,
                                      media::ColorSpace video_frame_color_space,
                                      const gfx::ColorSpace& video_color_space,
-                                     ResourceFormat y_format,
                                      const gfx::RectF& tex_coord_rect,
                                      uint8_t y,
                                      uint8_t u,
                                      uint8_t v,
                                      RenderPass* render_pass,
                                      const gfx::Rect& rect,
                                      const gfx::Rect& visible_rect,
                                      ResourceProvider* resource_provider) {
   YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601;
   if (video_frame_color_space == media::COLOR_SPACE_JPEG) {
     color_space = YUVVideoDrawQuad::JPEG;
   }
 
   const gfx::Rect opaque_rect(0, 0, 0, 0);
   const gfx::Size ya_tex_size = rect.size();
   const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize(
       media::PIXEL_FORMAT_NV12, media::VideoFrame::kUVPlane, rect.size());
 
   ResourceId y_resource = resource_provider->CreateResource(
-      rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT, y_format,
-      gfx::ColorSpace());
+      rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT,
+      resource_provider->YuvResourceFormat(8), gfx::ColorSpace());
   ResourceId u_resource = resource_provider->CreateResource(
       uv_tex_size, ResourceProvider::TEXTURE_HINT_DEFAULT, RGBA_8888,
       gfx::ColorSpace());
   ResourceId v_resource = u_resource;
   ResourceId a_resource = 0;
 
   std::vector<uint8_t> y_pixels(ya_tex_size.GetArea(), y);
   resource_provider->CopyToResource(y_resource, y_pixels.data(), ya_tex_size);
 
   // U goes in the R component and V goes in the G component.
@@ skipping 639 matching lines @@
         resource_provider_.get());
     pass_list->push_back(std::move(pass));
   }
 
   void SetUp() override {
     GLRendererPixelTest::SetUp();
     video_resource_updater_.reset(new VideoResourceUpdater(
         output_surface_->context_provider(), resource_provider_.get()));
   }
 
-  void DisableOneComponentTextures() {
-    TestInProcessContextProvider* context_provider =
-        GetTestInProcessContextProvider();
-    context_provider->SetDisableOneComponentTextures(true);
-  }
-
   std::unique_ptr<VideoResourceUpdater> video_resource_updater_;
-
- protected:
-  TestInProcessContextProvider* GetTestInProcessContextProvider() {
-    return static_cast<TestInProcessContextProvider*>(
-        output_surface_->context_provider());
-  }
-};
-
-enum class HighbitTexture {
-  Y8,
-  RGBA_8888,
-  LUMINANCE_F16,  // need --use-gpu-in-tests
 };
 
 class VideoGLRendererPixelHiLoTest
     : public VideoGLRendererPixelTest,
-      public ::testing::WithParamInterface<
-          ::testing::tuple<bool, HighbitTexture>> {
- public:
-  void SetSupportHighbitTexture(HighbitTexture texture) {
-    TestInProcessContextProvider* context_provider =
-        GetTestInProcessContextProvider();
-    switch (texture) {
-      case HighbitTexture::Y8:
-        context_provider->SetDisableOneComponentTextures(false);
-        context_provider->SetSupportTextureHalfFloatLinear(false);
-        break;
-      case HighbitTexture::RGBA_8888:
-        context_provider->SetDisableOneComponentTextures(true);
-        context_provider->SetSupportTextureHalfFloatLinear(false);
-        break;
-      case HighbitTexture::LUMINANCE_F16:
-        context_provider->SetDisableOneComponentTextures(false);
-        context_provider->SetSupportTextureHalfFloatLinear(true);
-        break;
-    }
-  }
-
-  bool IsHalfFloatLinearSupported() {
-    if (extensions_.empty())
-      InitializeExtensions();
-
-    return extensions_.find("GL_OES_texture_half_float_linear") !=
-           extensions_.end();
-  }
-
- private:
-  void InitializeExtensions() {
-    std::string extensions = GetTestInProcessContextProvider()
-                                 ->ContextGL()
-                                 ->GetRequestableExtensionsCHROMIUM();
-    std::vector<std::string> tokens = base::SplitString(
-        extensions, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-    extensions_.insert(tokens.begin(), tokens.end());
-  }
-
-  std::set<std::string> extensions_;
-};
+      public ::testing::WithParamInterface<bool> {};
 
 TEST_P(VideoGLRendererPixelHiLoTest, SimpleYUVRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  const bool highbit = testing::get<0>(GetParam());
-  const HighbitTexture format = testing::get<1>(GetParam());
-  if (format == HighbitTexture::LUMINANCE_F16 && !IsHalfFloatLinearSupported())
-    return;
-
-  SetSupportHighbitTexture(format);
+  bool highbit = GetParam();
   CreateTestYUVVideoDrawQuad_Striped(
       shared_state, media::PIXEL_FORMAT_YV12, false, highbit,
       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), pass.get(),
       video_resource_updater_.get(), rect, rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
-  base::FilePath file_path =
-      base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png"));
-  // TODO(dshwang): investigate why results per configuraion are so different.
-  // crbug.com/622133
-  if (format == HighbitTexture::RGBA_8888) {
-    // Color space is so different, because this path doesn't respect video
-    // color profile.
-    file_path = base::FilePath(FILE_PATH_LITERAL("yuv_stripes_rgba.png"));
-  }
-  EXPECT_TRUE(this->RunPixelTest(
-      &pass_list, file_path,
-      // All pixels can be off by two, but any more than that is an error.
-      FuzzyPixelComparator(true, 100.f, 0.f, 2.f, 2, 0)));
+  EXPECT_TRUE(
+      this->RunPixelTest(&pass_list,
+                         base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")),
+                         FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_P(VideoGLRendererPixelHiLoTest, ClippedYUVRect) {
   gfx::Rect viewport(this->device_viewport_size_);
   gfx::Rect draw_rect(this->device_viewport_size_.width() * 1.5,
                       this->device_viewport_size_.height() * 1.5);
 
   RenderPassId id(1, 1);
   std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, viewport);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), viewport, pass.get());
 
-  const bool highbit = testing::get<0>(GetParam());
-  const HighbitTexture format = testing::get<1>(GetParam());
-  if (format == HighbitTexture::LUMINANCE_F16 && !IsHalfFloatLinearSupported())
-    return;
-
-  SetSupportHighbitTexture(format);
+  bool highbit = GetParam();
   CreateTestYUVVideoDrawQuad_Striped(
       shared_state, media::PIXEL_FORMAT_YV12, false, highbit,
       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), pass.get(),
       video_resource_updater_.get(), draw_rect, viewport,
       resource_provider_.get());
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
-  base::FilePath file_path =
-      base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped.png"));
-  if (format == HighbitTexture::RGBA_8888) {
-    file_path =
-        base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped_rgba.png"));
-  }
   EXPECT_TRUE(this->RunPixelTest(
-      &pass_list, file_path,
-      // All pixels can be off by two, but any more than that is an error.
-      FuzzyPixelComparator(true, 100.f, 0.f, 2.f, 2, 0)));
+      &pass_list, base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped.png")),
+      FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_F(VideoGLRendererPixelHiLoTest, OffsetYUVRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
@@ skipping 31 matching lines @@
   pass_list.push_back(std::move(pass));
 
   // If we didn't get black out of the YUV values above, then we probably have a
   // color range issue.
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("black.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
 // First argument (test case prefix) is intentionally left empty.
-INSTANTIATE_TEST_CASE_P(
-    ,
-    VideoGLRendererPixelHiLoTest,
-    ::testing::Combine(::testing::Bool(),
-                       ::testing::Values(HighbitTexture::Y8,
-                                         HighbitTexture::LUMINANCE_F16,
-                                         HighbitTexture::RGBA_8888)));
+INSTANTIATE_TEST_CASE_P(, VideoGLRendererPixelHiLoTest, ::testing::Bool());
 
 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
@@ skipping 13 matching lines @@
 
 TEST_F(VideoGLRendererPixelTest, SimpleNV12JRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  ResourceFormat y_format =
-      video_resource_updater_->YuvResourceFormat(8, media::PIXEL_FORMAT_NV12);
-
   // YUV of (149,43,21) should be green (0,255,0) in RGB.
   CreateTestYUVVideoDrawQuad_NV12(
       shared_state, media::COLOR_SPACE_JPEG, gfx::ColorSpace::CreateJpeg(),
-      y_format, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(),
-      rect, rect, resource_provider_.get());
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(), rect, rect,
+      resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("green.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
 // Test that a YUV video doesn't bleed outside of its tex coords when the
 // tex coord rect is only a partial subrectangle of the coded contents.
 TEST_F(VideoGLRendererPixelTest, YUVEdgeBleed) {
   RenderPassList pass_list;
   CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12, media::COLOR_SPACE_JPEG,
                       &pass_list);
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("green.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_F(VideoGLRendererPixelTest, YUVAEdgeBleed) {
   RenderPassList pass_list;
   CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12A, media::COLOR_SPACE_UNSPECIFIED,
                       &pass_list);
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("green.png")),
-                                 FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, TextureQuadEdgeBleed) {
-  // VideoResourceUpdater::CreateForSoftwarePlanes() converts YUV frame to RGBA
-  // texture.
-  DisableOneComponentTextures();
-  RenderPassList pass_list;
-  CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12, media::COLOR_SPACE_JPEG,
-                      &pass_list);
-  EXPECT_TRUE(this->RunPixelTest(&pass_list,
-                                 base::FilePath(FILE_PATH_LITERAL("green.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
@@ skipping 1894 matching lines @@
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list, base::FilePath(FILE_PATH_LITERAL("spiral.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc