Add DirectComposition overlay support.

gpu/ipc/service/direct_composition_surface_win_unittest.cc

 // Copyright 2017 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 "gpu/ipc/service/direct_composition_surface_win.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "skia/ext/platform_canvas.h"
+#include "skia/ext/skia_utils_win.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/win/hidden_window.h"
+#include "ui/gfx/skia_util.h"
+#include "ui/gfx/transform.h"
+#include "ui/gl/dc_renderer_layer_params.h"
 #include "ui/gl/gl_angle_util_win.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_image_dxgi.h"
 #include "ui/gl/init/gl_factory.h"
+#include "ui/platform_window/platform_window_delegate.h"
+#include "ui/platform_window/win/win_window.h"
 
 namespace gpu {
 namespace {
 
+bool CheckIfDCSupported() {
+  if (!gl::QueryDirectCompositionDevice(
+          gl::QueryD3D11DeviceObjectFromANGLE())) {
+    LOG(WARNING)
+        << "GL implementation not using DirectComposition, skipping test.";
+    return false;
+  }
+  return true;
+}
+
 class TestImageTransportSurfaceDelegate
     : public ImageTransportSurfaceDelegate,
       public base::SupportsWeakPtr<TestImageTransportSurfaceDelegate> {
  public:
   ~TestImageTransportSurfaceDelegate() override {}
 
   // ImageTransportSurfaceDelegate implementation.
   void DidCreateAcceleratedSurfaceChildWindow(
       SurfaceHandle parent_window,
-      SurfaceHandle child_window) override {}
+      SurfaceHandle child_window) override {
+    if (parent_window)
+      ::SetParent(child_window, parent_window);
+  }
   void DidSwapBuffersComplete(SwapBuffersCompleteParams params) override {}
   const gles2::FeatureInfo* GetFeatureInfo() const override { return nullptr; }
   void SetLatencyInfoCallback(const LatencyInfoCallback& callback) override {}
   void UpdateVSyncParameters(base::TimeTicks timebase,
                              base::TimeDelta interval) override {}
   void AddFilter(IPC::MessageFilter* message_filter) override {}
   int32_t GetRouteID() const override { return 0; }
 };
 
+class TestPlatformDelegate : public ui::PlatformWindowDelegate {
+ public:
+  // ui::PlatformWindowDelegate implementation.
+  void OnBoundsChanged(const gfx::Rect& new_bounds) override {}
+  void OnDamageRect(const gfx::Rect& damaged_region) override {}
+  void DispatchEvent(ui::Event* event) override {}
+  void OnCloseRequest() override {}
+  void OnClosed() override {}
+  void OnWindowStateChanged(ui::PlatformWindowState new_state) override {}
+  void OnLostCapture() override {}
+  void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget,
+                                    float device_pixel_ratio) override {}
+  void OnAcceleratedWidgetDestroyed() override {}
+  void OnActivationChanged(bool active) override {}
+};
+
 void RunPendingTasks(scoped_refptr<base::TaskRunner> task_runner) {
   base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner->PostTask(FROM_HERE,
                         Bind(&base::WaitableEvent::Signal, Unretained(&done)));
   done.Wait();
 }
 
 void DestroySurface(scoped_refptr<DirectCompositionSurfaceWin> surface) {
   scoped_refptr<base::TaskRunner> task_runner =
       surface->GetWindowTaskRunnerForTesting();
   DCHECK(surface->HasOneRef());
 
   surface = nullptr;
 
   // Ensure that the ChildWindowWin posts the task to delete the thread to the
   // main loop before doing RunUntilIdle. Otherwise the child threads could
   // outlive the main thread.
   RunPendingTasks(task_runner);
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST(DirectCompositionSurfaceTest, TestMakeCurrent) {
-  if (!gl::QueryDirectCompositionDevice(
-          gl::QueryD3D11DeviceObjectFromANGLE())) {
-    LOG(WARNING)
-        << "GL implementation not using DirectComposition, skipping test.";
+  if (!CheckIfDCSupported())
     return;
-  }
 
   TestImageTransportSurfaceDelegate delegate;
 
   scoped_refptr<DirectCompositionSurfaceWin> surface1(
       new DirectCompositionSurfaceWin(delegate.AsWeakPtr(),
                                       ui::GetHiddenWindow()));
   EXPECT_TRUE(surface1->Initialize());
   surface1->SetEnableDCLayers(true);
 
   scoped_refptr<gl::GLContext> context1 = gl::init::CreateGLContext(
@@ skipping 42 matching lines @@
   EXPECT_TRUE(context1->MakeCurrent(surface1.get()));
   context2 = nullptr;
   context1 = nullptr;
 
   DestroySurface(std::move(surface1));
   DestroySurface(std::move(surface2));
 }
 
 // Tests that switching using EnableDCLayers works.
 TEST(DirectCompositionSurfaceTest, DXGIDCLayerSwitch) {
-  if (!gl::QueryDirectCompositionDevice(
-          gl::QueryD3D11DeviceObjectFromANGLE())) {
-    LOG(WARNING)
-        << "GL implementation not using DirectComposition, skipping test.";
+  if (!CheckIfDCSupported())
     return;
-  }
 
   TestImageTransportSurfaceDelegate delegate;
 
   scoped_refptr<DirectCompositionSurfaceWin> surface(
       new DirectCompositionSurfaceWin(delegate.AsWeakPtr(),
                                       ui::GetHiddenWindow()));
   EXPECT_TRUE(surface->Initialize());
 
   scoped_refptr<gl::GLContext> context =
       gl::init::CreateGLContext(nullptr, surface.get(), gl::GLContextAttribs());
@@ skipping 29 matching lines @@
 
   // Surface switched to use IDXGISwapChain, so must draw to entire
   // surface.
   EXPECT_FALSE(surface->SetDrawRectangle(gfx::Rect(0, 0, 50, 50)));
   EXPECT_TRUE(surface->SetDrawRectangle(gfx::Rect(0, 0, 100, 100)));
   EXPECT_TRUE(surface->swap_chain());
 
   context = nullptr;
   DestroySurface(std::move(surface));
 }
+
+SkBitmap ReadBackWindow(HWND window, const gfx::Rect& snapshot_bounds) {
+  std::unique_ptr<SkCanvas> canvas = skia::CreatePlatformCanvas(

[bungeman-skia, 2017/03/29 14:11:53]

As far as I know we're trying to remove skia::CreatePlatformCanvas. It appears
that there is no actual use of 'canvas' here, the code is just being used for
the side effect of creating an HDC. Indeed, there's no actual use of SkBitmap
here either (we're also trying to phase out SkBitmap where possible), it's just
being used as a means to extract a single pixel value out of an HDC (this
function could just take an x,y coordinate and return the pixel value at that
location directly instead of a whole bitmap).

In other words, it doesn't seem like Skia is used here at all, just the logic in
raster_handle_allocator_win.cc around creating and destroying an HDC.

+      snapshot_bounds.right(), snapshot_bounds.bottom(), false);
+  HDC mem_hdc = skia::GetNativeDrawingContext(canvas.get());
+
+  // Grab a copy of the window. Use PrintWindow because it works even when the
+  // window's partially occluded. The PW_RENDERFULLCONTENT flag is undocumented,
+  // but works starting in Windows 8.1. It allows for capturing the contents of
+  // the window that are drawn using DirectComposition.
+  UINT flags = PW_CLIENTONLY | PW_RENDERFULLCONTENT;
+
+  BOOL result = PrintWindow(window, mem_hdc, flags);
+  if (!result)
+    PLOG(ERROR) << "Failed to print window";
+
+  SkBitmap bitmap;
+  canvas->readPixels(gfx::RectToSkIRect(snapshot_bounds), &bitmap);
+
+  return bitmap;
+}
+
+class DirectCompositionPixelTest : public testing::Test {
+ public:
+  DirectCompositionPixelTest()
+      : window_(&platform_delegate_, gfx::Rect(0, 0, 100, 100)) {}
+
+ protected:
+  void InitializeSurface() {
+    static_cast<ui::PlatformWindow*>(&window_)->Show();
+
+    surface_ =
+        new DirectCompositionSurfaceWin(delegate_.AsWeakPtr(), window_.hwnd());
+    EXPECT_TRUE(surface_->Initialize());
+  }
+
+  void PixelTestSwapChain(bool layers_enabled) {
+    if (!CheckIfDCSupported())
+      return;
+
+    InitializeSurface();
+
+    surface_->SetEnableDCLayers(layers_enabled);
+    gfx::Size window_size(100, 100);
+
+    scoped_refptr<gl::GLContext> context = gl::init::CreateGLContext(
+        nullptr, surface_.get(), gl::GLContextAttribs());
+    EXPECT_TRUE(surface_->Resize(window_size, 1.0, true));
+    EXPECT_TRUE(surface_->SetDrawRectangle(gfx::Rect(window_size)));
+    EXPECT_TRUE(context->MakeCurrent(surface_.get()));
+
+    glClearColor(1.0, 0.0, 0.0, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface_->SwapBuffers());
+
+    // Ensure DWM swap completed.
+    Sleep(1000);
+
+    SkBitmap bitmap = ReadBackWindow(window_.hwnd(), gfx::Rect(window_size));
+    EXPECT_EQ(SK_ColorRED, bitmap.getColor(50, 50));
+
+    EXPECT_TRUE(context->IsCurrent(surface_.get()));
+
+    context = nullptr;
+    DestroySurface(std::move(surface_));
+  }
+
+  TestPlatformDelegate platform_delegate_;
+  TestImageTransportSurfaceDelegate delegate_;
+  ui::WinWindow window_;
+  scoped_refptr<DirectCompositionSurfaceWin> surface_;
+};
+
+TEST_F(DirectCompositionPixelTest, DCLayersEnabled) {
+  PixelTestSwapChain(true);
+}
+
+TEST_F(DirectCompositionPixelTest, DCLayersDisabled) {
+  PixelTestSwapChain(false);
+}
+
+base::win::ScopedComPtr<ID3D11Texture2D> CreateNV12Texture(
+    const base::win::ScopedComPtr<ID3D11Device>& d3d11_device,
+    const gfx::Size& size) {
+  D3D11_TEXTURE2D_DESC desc = {};
+  desc.Width = size.width();
+  desc.Height = size.height();
+  desc.MipLevels = 1;
+  desc.ArraySize = 1;
+  desc.Format = DXGI_FORMAT_NV12;
+  desc.Usage = D3D11_USAGE_DEFAULT;
+  desc.SampleDesc.Count = 1;
+  desc.BindFlags = 0;
+
+  std::vector<char> image_data(size.width() * size.height() * 3 / 2);
+  // Y, U, and V should all be Oxff. Output color should be pink.
+  memset(&image_data[0], 0xff, size.width() * size.height() * 3 / 2);
+
+  D3D11_SUBRESOURCE_DATA data = {};
+  data.pSysMem = (const void*)&image_data[0];
+  data.SysMemPitch = size.width();
+
+  base::win::ScopedComPtr<ID3D11Texture2D> texture;
+  HRESULT hr = d3d11_device->CreateTexture2D(&desc, &data, texture.Receive());
+  CHECK(SUCCEEDED(hr));
+  return texture;
+}
+
+bool AreColorsSimilar(int a, int b) {
+  // The precise colors may differ depending on the video processor, so allow
+  // a margin for error.
+  const int kMargin = 10;
+  return abs(SkColorGetA(a) - SkColorGetA(b)) < kMargin &&
+         abs(SkColorGetR(a) - SkColorGetR(b)) < kMargin &&
+         abs(SkColorGetG(a) - SkColorGetG(b)) < kMargin &&
+         abs(SkColorGetB(a) - SkColorGetB(b)) < kMargin;
+}
+
+TEST_F(DirectCompositionPixelTest, VideoSwapchain) {
+  if (!CheckIfDCSupported())
+    return;
+  InitializeSurface();
+  surface_->SetEnableDCLayers(true);
+  gfx::Size window_size(100, 100);
+
+  scoped_refptr<gl::GLContext> context = gl::init::CreateGLContext(
+      nullptr, surface_.get(), gl::GLContextAttribs());
+  EXPECT_TRUE(surface_->Resize(window_size, 1.0, true));
+
+  base::win::ScopedComPtr<ID3D11Device> d3d11_device =
+      gl::QueryD3D11DeviceObjectFromANGLE();
+
+  gfx::Size texture_size(50, 50);
+  base::win::ScopedComPtr<ID3D11Texture2D> texture =
+      CreateNV12Texture(d3d11_device, texture_size);
+
+  scoped_refptr<gl::GLImageDXGI> image_dxgi(
+      new gl::GLImageDXGI(texture_size, nullptr));
+  image_dxgi->SetTexture(texture, 0);
+
+  ui::DCRendererLayerParams params(false, gfx::Rect(), 1, gfx::Transform(),
+                                   image_dxgi.get(),
+                                   gfx::RectF(gfx::Rect(texture_size)),
+                                   gfx::Rect(window_size), 0, 0, 1.0, 0);
+  surface_->ScheduleDCLayer(params);
+
+  EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface_->SwapBuffers());
+  Sleep(1000);
+
+  SkBitmap bitmap = ReadBackWindow(window_.hwnd(), gfx::Rect(window_size));
+  SkColor expected_color = SkColorSetRGB(0xff, 0xb7, 0xff);
+  SkColor actual_color = bitmap.getColor(75, 75);
+  EXPECT_TRUE(AreColorsSimilar(expected_color, actual_color))
+      << std::hex << "Expected " << expected_color << " Actual "
+      << actual_color;
+
+  context = nullptr;
+  DestroySurface(std::move(surface_));
+}
+
 }  // namespace
 }  // namespace gpu