Simplify SkiaOutputSurfaceImplTests

The tests setup and general structure was more complicated than
necessary. Cleanup before landing some new tests. No changes to the test
logic itself.

Bug: 1047217
Change-Id: I6c676f67385e1f712a8479c75da52e216dc58b2b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2031188Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Commit-Queue: kylechar <kylechar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#736944}

components/viz/service/display_embedder/skia_output_surface_impl_unittest.cc

@@ -8,11 +8,8 @@
 #include <utility>
 #include <vector>
 
-#include "base/base64.h"
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/run_loop.h"
-#include "base/test/scoped_feature_list.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/pixel_test_utils.h"
 #include "components/viz/common/display/renderer_settings.h"
@@ -23,9 +20,7 @@
 #include "components/viz/service/display_embedder/skia_output_surface_dependency_impl.h"
 #include "components/viz/service/gl/gpu_service_impl.h"
 #include "components/viz/test/test_gpu_service_holder.h"
-#include "gpu/command_buffer/service/scheduler.h"
 #include "gpu/command_buffer/service/service_utils.h"
-#include "gpu/ipc/gpu_in_process_thread_service.h"
 #include "gpu/vulkan/buildflags.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -33,79 +28,55 @@
 
 #if BUILDFLAG(ENABLE_VULKAN)
 #include "gpu/vulkan/tests/native_window.h"
-#include "gpu/vulkan/vulkan_implementation.h"
 #endif
 
 namespace viz {
+namespace {
 
-const gfx::Rect kSurfaceRect(0, 0, 100, 100);
+constexpr gfx::Rect kSurfaceRect(0, 0, 100, 100);
+constexpr SkColor kOutputColor = SK_ColorRED;
 
-static void ExpectEquals(SkBitmap actual, SkBitmap expected) {
-  EXPECT_EQ(actual.dimensions(), expected.dimensions());
-  auto expected_url = cc::GetPNGDataUrl(expected);
-  auto actual_url = cc::GetPNGDataUrl(actual);
-  EXPECT_TRUE(actual_url == expected_url);
-}
+}  // namespace
 
 class SkiaOutputSurfaceImplTest : public testing::TestWithParam<bool> {
  public:
+  SkiaOutputSurfaceImplTest();
+
+  bool CreateNativeWindow() const { return GetParam(); }
+
+  GpuServiceImpl* GetGpuService() {
+    return TestGpuServiceHolder::GetInstance()->gpu_service();
+  }
+
+  void SetUpSkiaOutputSurfaceImpl();
+
+  // Paints and submits root RenderPass with a solid color rect of |size|.
+  gpu::SyncToken PaintRootRenderPass(const gfx::Rect& output_rect,
+                                     base::OnceClosure closure);
+
   void CheckSyncTokenOnGpuThread(const gpu::SyncToken& sync_token);
-  void CopyRequestCallbackOnGpuThread(const SkColor output_color,
-                                      const gfx::Rect& output_rect,
+  void CopyRequestCallbackOnGpuThread(const gfx::Rect& output_rect,
                                       const gfx::ColorSpace& color_space,
                                       std::unique_ptr<CopyOutputResult> result);
-
- protected:
-  SkiaOutputSurfaceImplTest()
-      : output_surface_client_(std::make_unique<cc::FakeOutputSurfaceClient>()),
-        wait_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-              base::WaitableEvent::InitialState::NOT_SIGNALED),
-        on_screen_(GetParam()) {}
-  inline void SetUp() override { SetUpSkiaOutputSurfaceImpl(); }
-  void TearDown() override;
   void BlockMainThread();
   void UnblockMainThread();
 
-  GpuServiceImpl* gpu_service() { return gpu_service_holder_->gpu_service(); }
-
-  TestGpuServiceHolder* gpu_service_holder_;
+ protected:
+  gl::DisableNullDrawGLBindings enable_pixel_output_;
   std::unique_ptr<SkiaOutputSurface> output_surface_;
-
- private:
-  void SetUpSkiaOutputSurfaceImpl();
-
-  std::unique_ptr<cc::FakeOutputSurfaceClient> output_surface_client_;
-  std::unique_ptr<base::test::ScopedFeatureList> scoped_feature_list_;
+  cc::FakeOutputSurfaceClient output_surface_client_;
   base::WaitableEvent wait_;
-  const bool on_screen_;
-  gl::DisableNullDrawGLBindings enable_pixel_output_;
 };
 
-void SkiaOutputSurfaceImplTest::BlockMainThread() {
-  wait_.Wait();
-}
-
-void SkiaOutputSurfaceImplTest::UnblockMainThread() {
-  DCHECK(!wait_.IsSignaled());
-  wait_.Signal();
-}
-
-void SkiaOutputSurfaceImplTest::TearDown() {
-  output_surface_.reset();
-  scoped_feature_list_.reset();
+SkiaOutputSurfaceImplTest::SkiaOutputSurfaceImplTest()
+    : wait_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+            base::WaitableEvent::InitialState::NOT_SIGNALED) {
+  SetUpSkiaOutputSurfaceImpl();
 }
 
 void SkiaOutputSurfaceImplTest::SetUpSkiaOutputSurfaceImpl() {
-  // SkiaOutputSurfaceImplOnGpu requires UseSkiaRenderer.
-  const char enable_features[] = "UseSkiaRenderer";
-  const char disable_features[] = "";
-  scoped_feature_list_ = std::make_unique<base::test::ScopedFeatureList>();
-  scoped_feature_list_->InitFromCommandLine(enable_features, disable_features);
-  gpu_service_holder_ = TestGpuServiceHolder::GetInstance();
-
-  // Set up the SkiaOutputSurfaceImpl.
   gpu::SurfaceHandle surface_handle_ = gpu::kNullSurfaceHandle;
-  if (on_screen_) {
+  if (CreateNativeWindow()) {
 #if BUILDFLAG(ENABLE_VULKAN) && defined(USE_X11)
     surface_handle_ = gpu::CreateNativeWindow(kSurfaceRect);
 #else
@@ -113,39 +84,58 @@ void SkiaOutputSurfaceImplTest::SetUpSkiaOutputSurfaceImpl() {
     NOTREACHED();
 #endif
   }
+
+  RendererSettings settings;
+  settings.use_skia_renderer = true;
   output_surface_ = SkiaOutputSurfaceImpl::Create(
-      std::make_unique<SkiaOutputSurfaceDependencyImpl>(gpu_service(),
+      std::make_unique<SkiaOutputSurfaceDependencyImpl>(GetGpuService(),
                                                         surface_handle_),
-      RendererSettings());
-  output_surface_->BindToClient(output_surface_client_.get());
+      settings);
+  output_surface_->BindToClient(&output_surface_client_);
+}
+
+gpu::SyncToken SkiaOutputSurfaceImplTest::PaintRootRenderPass(
+    const gfx::Rect& rect,
+    base::OnceClosure closure) {
+  SkPaint paint;
+  paint.setColor(kOutputColor);
+  SkCanvas* root_canvas = output_surface_->BeginPaintCurrentFrame();
+  root_canvas->drawRect(
+      SkRect::MakeXYWH(rect.x(), rect.y(), rect.height(), rect.width()), paint);
+  return output_surface_->SubmitPaint(std::move(closure));
+}
+
+void SkiaOutputSurfaceImplTest::BlockMainThread() {
+  wait_.Wait();
+}
+
+void SkiaOutputSurfaceImplTest::UnblockMainThread() {
+  DCHECK(!wait_.IsSignaled());
+  wait_.Signal();
 }
 
 void SkiaOutputSurfaceImplTest::CheckSyncTokenOnGpuThread(
     const gpu::SyncToken& sync_token) {
   EXPECT_TRUE(
-      gpu_service()->sync_point_manager()->IsSyncTokenReleased(sync_token));
+      GetGpuService()->sync_point_manager()->IsSyncTokenReleased(sync_token));
   UnblockMainThread();
 }
 
 void SkiaOutputSurfaceImplTest::CopyRequestCallbackOnGpuThread(
-    const SkColor output_color,
     const gfx::Rect& output_rect,
     const gfx::ColorSpace& color_space,
     std::unique_ptr<CopyOutputResult> result) {
-  std::unique_ptr<SkBitmap> result_bitmap;
-  result_bitmap = std::make_unique<SkBitmap>(result->AsSkBitmap());
-  EXPECT_EQ(result_bitmap->width(), output_rect.width());
-  EXPECT_EQ(result_bitmap->height(), output_rect.height());
-
-  std::vector<SkPMColor> expected_pixels(
-      output_rect.width() * output_rect.height(),
-      SkPreMultiplyColor(output_color));
+  SkBitmap result_bitmap(result->AsSkBitmap());
+  EXPECT_EQ(result_bitmap.width(), output_rect.width());
+  EXPECT_EQ(result_bitmap.height(), output_rect.height());
+
   SkBitmap expected;
-  expected.installPixels(
-      SkImageInfo::MakeN32Premul(output_rect.width(), output_rect.height(),
-                                 color_space.ToSkColorSpace()),
-      expected_pixels.data(), output_rect.width() * sizeof(SkColor));
-  ExpectEquals(*result_bitmap.get(), expected);
+  expected.allocPixels(SkImageInfo::MakeN32Premul(
+      output_rect.width(), output_rect.height(), color_space.ToSkColorSpace()));
+  expected.eraseColor(kOutputColor);
+
+  EXPECT_TRUE(cc::MatchesBitmap(result_bitmap, expected,
+                                cc::ExactPixelComparator(false)));
 
   UnblockMainThread();
 }
@@ -162,20 +152,14 @@ INSTANTIATE_TEST_SUITE_P(SkiaOutputSurfaceImplTest,
 TEST_P(SkiaOutputSurfaceImplTest, SubmitPaint) {
   output_surface_->Reshape(kSurfaceRect.size(), 1, gfx::ColorSpace(),
                            /*has_alpha=*/false, /*use_stencil=*/false);
-  SkCanvas* root_canvas = output_surface_->BeginPaintCurrentFrame();
-  SkPaint paint;
-  const SkColor output_color = SK_ColorRED;
-  const gfx::Rect output_rect(0, 0, 10, 10);
-  paint.setColor(output_color);
-  SkRect rect = SkRect::MakeWH(output_rect.width(), output_rect.height());
-  root_canvas->drawRect(rect, paint);
+  constexpr gfx::Rect output_rect(0, 0, 10, 10);
 
   bool on_finished_called = false;
   base::OnceClosure on_finished =
       base::BindOnce([](bool* result) { *result = true; }, &on_finished_called);
 
   gpu::SyncToken sync_token =
-      output_surface_->SubmitPaint(std::move(on_finished));
+      PaintRootRenderPass(output_rect, std::move(on_finished));
   EXPECT_TRUE(sync_token.HasData());
 
   // Copy the output
@@ -183,10 +167,9 @@ TEST_P(SkiaOutputSurfaceImplTest, SubmitPaint) {
   auto request = std::make_unique<CopyOutputRequest>(
       CopyOutputRequest::ResultFormat::RGBA_BITMAP,
       base::BindOnce(&SkiaOutputSurfaceImplTest::CopyRequestCallbackOnGpuThread,
-                     base::Unretained(this), output_color, output_rect,
-                     color_space));
+                     base::Unretained(this), output_rect, color_space));
   request->set_result_task_runner(
-      gpu_service_holder_->gpu_thread_task_runner());
+      TestGpuServiceHolder::GetInstance()->gpu_thread_task_runner());
   copy_output::RenderPassGeometry geometry;
   geometry.result_bounds = output_rect;
   geometry.result_selection = output_rect;
@@ -214,13 +197,8 @@ TEST_P(SkiaOutputSurfaceImplTest, SupportsColorSpaceChange) {
                              /*has_alpha=*/false, /*use_stencil=*/false);
 
     // Draw something, it's not important what.
-    SkCanvas* root_canvas = output_surface_->BeginPaintCurrentFrame();
-    SkPaint paint;
-    paint.setColor(SK_ColorRED);
-    root_canvas->drawRect(SkRect::MakeWH(10, 10), paint);
-
     base::RunLoop run_loop;
-    output_surface_->SubmitPaint(run_loop.QuitClosure());
+    PaintRootRenderPass(kSurfaceRect, run_loop.QuitClosure());
 
     OutputSurfaceFrame frame;
     frame.size = kSurfaceRect.size();