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 "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 resources =
+  VideoFrameExternalResources external_resources =
       video_resource_updater->CreateExternalResourcesFromVideoFrame(

[dshwang, 2016/10/18 19:14:36]

It produces RGBA Texture resource if the GL context don't support one component
texture. Pixel test uses this path to make sure TextureQuad handle bleeding edge
issue.

The path is tested first time and reveals two hidden bugs, so this CL fixes
them.

[enne (OOO), 2016/10/19 19:04:03]

What were the bugs?

[dshwang, 2016/10/20 18:57:55]

1. texture size can be zero in GLRenderer::EnqueueTextureQuad because some
clients doesn't set size.
2. SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels() doesn't convert video
frame correctly when coded size is bigger than visual size.

See below comments for more details.

           video_frame);
 
-  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]));
+  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);
   }
 
-  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()));
+  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());
+
+      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;
+    }
+    default:
+      NOTREACHED();
   }
-
-  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);
 }
 
 // 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:
     case media::PIXEL_FORMAT_YV12:
       format = media::PIXEL_FORMAT_YUV420P10;
@@ skipping 40 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,
-      resource_provider->YuvResourceFormat(8), gfx::ColorSpace());
+      rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT, y_format,
+      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 567 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,
 };
 
 class VideoGLRendererPixelHiLoTest
     : public VideoGLRendererPixelTest,
-      public ::testing::WithParamInterface<bool> {};
+      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;
+    }
+  }
+};
 
 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());
 
-  bool highbit = GetParam();
+  const bool highbit = testing::get<0>(GetParam());
+  const HighbitTexture format = testing::get<1>(GetParam());
+  SetSupportHighbitTexture(format);
   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));
 
-  EXPECT_TRUE(
-      this->RunPixelTest(&pass_list,
-                         base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")),
-                         FuzzyPixelOffByOneComparator(true)));
+  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)));
 }
 
 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());
 
-  bool highbit = GetParam();
+  const bool highbit = testing::get<0>(GetParam());
+  const HighbitTexture format = testing::get<1>(GetParam());
+  SetSupportHighbitTexture(format);
   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, base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped.png")),
-      FuzzyPixelOffByOneComparator(true)));
+      &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)));
 }
 
 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::Bool());
+INSTANTIATE_TEST_CASE_P(
+    ,
+    VideoGLRendererPixelHiLoTest,
+    ::testing::Combine(
+        ::testing::Bool(),
+        ::testing::Values(HighbitTexture::Y8,
+                          // LUMINANCE_F16 requires --use-gpu-in-tests
+                          // HighbitTexture::LUMINANCE_F16,
+                          HighbitTexture::RGBA_8888)));
 
 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);
+
   // YUV of (149,43,21) should be green (0,255,0) in RGB.
   CreateTestYUVVideoDrawQuad_NV12(
       shared_state, media::COLOR_SPACE_JPEG, gfx::ColorSpace::CreateJpeg(),
-      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(), rect, rect,
-      resource_provider_.get());
+      y_format, 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 =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // Dark grey in JPEG color range (in MPEG, this is black).
@@ skipping 1867 matching lines @@
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list, base::FilePath(FILE_PATH_LITERAL("spiral.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc