Reconcile the multiple GLImageDXGI types

(1) Merge GLImageDXGIHandle into GLImageDXGI. For those three override functions
BindTexImage(), GetInternalFormat() and ReleaseTexImage(), Check handle_
before continuing processing handle related code.
Rename GLImageDXGIHandle::Initialize() to GLImageDXGI::InitializeHandle()

(2) Merge GLImageDXGIBase into GLImageDXGI.

Bug:776010

Change-Id: Id2906a4fcb19e4286c13f718ae1913e73994d303
Reviewed-on: https://chromium-review.googlesource.com/c/1361588
Commit-Queue: Maggie Chen <magchen@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#615770}

gpu/ipc/service/direct_composition_surface_win.cc

@@ -511,7 +511,7 @@ class DCLayerTree::SwapChainPresenter {
   // Present to a decode swap chain created from compatible video decoder
   // buffers using given |image_dxgi| with destination size |swap_chain_size|.
   // Sets |needs_commit| to true if a commit is needed. Returns true on success.
-  bool PresentToDecodeSwapChain(gl::GLImageDXGIBase* image_dxgi,
+  bool PresentToDecodeSwapChain(gl::GLImageDXGI* image_dxgi,
                                 const gfx::Rect& content_rect,
                                 const gfx::Size& swap_chain_size,
                                 bool* needs_commit);
@@ -947,7 +947,7 @@ bool DCLayerTree::SwapChainPresenter::UpdateVisuals(
 }
 
 bool DCLayerTree::SwapChainPresenter::PresentToDecodeSwapChain(
-    gl::GLImageDXGIBase* image_dxgi,
+    gl::GLImageDXGI* image_dxgi,
     const gfx::Rect& content_rect,
     const gfx::Size& swap_chain_size,
     bool* needs_commit) {
@@ -1052,8 +1052,8 @@ bool DCLayerTree::SwapChainPresenter::PresentToSwapChain(
     bool* needs_commit) {
   *needs_commit = false;
 
-  gl::GLImageDXGIBase* image_dxgi =
-      gl::GLImageDXGIBase::FromGLImage(params.y_image.get());
+  gl::GLImageDXGI* image_dxgi =
+      gl::GLImageDXGI::FromGLImage(params.y_image.get());
   gl::GLImageMemory* y_image_memory =
       gl::GLImageMemory::FromGLImage(params.y_image.get());
   gl::GLImageMemory* uv_image_memory =

gpu/ipc/service/direct_composition_surface_win_unittest.cc

@@ -901,9 +901,10 @@ TEST_F(DirectCompositionPixelTest, VideoHandleSwapchain) {
   resource->CreateSharedHandle(nullptr, DXGI_SHARED_RESOURCE_READ, nullptr,
                                &handle);
   // The format doesn't matter, since we aren't binding.
-  scoped_refptr<gl::GLImageDXGIHandle> image_dxgi(
-      new gl::GLImageDXGIHandle(texture_size, 0, gfx::BufferFormat::RGBA_8888));
-  ASSERT_TRUE(image_dxgi->Initialize(base::win::ScopedHandle(handle)));
+  scoped_refptr<gl::GLImageDXGI> image_dxgi(
+      new gl::GLImageDXGI(texture_size, nullptr));
+  ASSERT_TRUE(image_dxgi->InitializeHandle(base::win::ScopedHandle(handle), 0,
+                                           gfx::BufferFormat::RGBA_8888));
 
   ui::DCRendererLayerParams params;
   params.y_image = image_dxgi;
@@ -951,9 +952,10 @@ TEST_F(DirectCompositionPixelTest, SkipVideoLayerEmptyBoundsRect) {
   resource->CreateSharedHandle(nullptr, DXGI_SHARED_RESOURCE_READ, nullptr,
                                &handle);
   // The format doesn't matter, since we aren't binding.
-  scoped_refptr<gl::GLImageDXGIHandle> image_dxgi(
-      new gl::GLImageDXGIHandle(texture_size, 0, gfx::BufferFormat::RGBA_8888));
-  ASSERT_TRUE(image_dxgi->Initialize(base::win::ScopedHandle(handle)));
+  scoped_refptr<gl::GLImageDXGI> image_dxgi(
+      new gl::GLImageDXGI(texture_size, nullptr));
+  ASSERT_TRUE(image_dxgi->InitializeHandle(base::win::ScopedHandle(handle), 0,
+                                           gfx::BufferFormat::RGBA_8888));
 
   // Layer with empty bounds rect.
   ui::DCRendererLayerParams params;
@@ -1006,9 +1008,10 @@ TEST_F(DirectCompositionPixelTest, SkipVideoLayerEmptyContentsRect) {
   resource->CreateSharedHandle(nullptr, DXGI_SHARED_RESOURCE_READ, nullptr,
                                &handle);
   // The format doesn't matter, since we aren't binding.
-  scoped_refptr<gl::GLImageDXGIHandle> image_dxgi(
-      new gl::GLImageDXGIHandle(texture_size, 0, gfx::BufferFormat::RGBA_8888));
-  ASSERT_TRUE(image_dxgi->Initialize(base::win::ScopedHandle(handle)));
+  scoped_refptr<gl::GLImageDXGI> image_dxgi(
+      new gl::GLImageDXGI(texture_size, nullptr));
+  ASSERT_TRUE(image_dxgi->InitializeHandle(base::win::ScopedHandle(handle), 0,
+                                           gfx::BufferFormat::RGBA_8888));
 
   // Layer with empty content rect.
   ui::DCRendererLayerParams params;
@@ -1060,9 +1063,10 @@ TEST_F(DirectCompositionPixelTest, NV12SwapChain) {
   resource->CreateSharedHandle(nullptr, DXGI_SHARED_RESOURCE_READ, nullptr,
                                &handle);
   // The format doesn't matter, since we aren't binding.
-  scoped_refptr<gl::GLImageDXGIHandle> image_dxgi(
-      new gl::GLImageDXGIHandle(texture_size, 0, gfx::BufferFormat::RGBA_8888));
-  ASSERT_TRUE(image_dxgi->Initialize(base::win::ScopedHandle(handle)));
+  scoped_refptr<gl::GLImageDXGI> image_dxgi(
+      new gl::GLImageDXGI(texture_size, nullptr));
+  ASSERT_TRUE(image_dxgi->InitializeHandle(base::win::ScopedHandle(handle), 0,
+                                           gfx::BufferFormat::RGBA_8888));
 
   // Pass content rect with odd with and height.  Surface should round up width
   // and height when creating swap chain.
@@ -1125,9 +1129,10 @@ TEST_F(DirectCompositionPixelTest, NonZeroBoundsOffset) {
   resource->CreateSharedHandle(nullptr, DXGI_SHARED_RESOURCE_READ, nullptr,
                                &handle);
   // The format doesn't matter, since we aren't binding.
-  scoped_refptr<gl::GLImageDXGIHandle> image_dxgi(
-      new gl::GLImageDXGIHandle(texture_size, 0, gfx::BufferFormat::RGBA_8888));
-  ASSERT_TRUE(image_dxgi->Initialize(base::win::ScopedHandle(handle)));
+  scoped_refptr<gl::GLImageDXGI> image_dxgi(
+      new gl::GLImageDXGI(texture_size, nullptr));
+  ASSERT_TRUE(image_dxgi->InitializeHandle(base::win::ScopedHandle(handle), 0,
+                                           gfx::BufferFormat::RGBA_8888));
 
   ui::DCRendererLayerParams params;
   params.y_image = image_dxgi;
@@ -1192,9 +1197,10 @@ TEST_F(DirectCompositionPixelTest, ResizeVideoLayer) {
   resource->CreateSharedHandle(nullptr, DXGI_SHARED_RESOURCE_READ, nullptr,
                                &handle);
   // The format doesn't matter, since we aren't binding.
-  scoped_refptr<gl::GLImageDXGIHandle> image_dxgi(
-      new gl::GLImageDXGIHandle(texture_size, 0, gfx::BufferFormat::RGBA_8888));
-  ASSERT_TRUE(image_dxgi->Initialize(base::win::ScopedHandle(handle)));
+  scoped_refptr<gl::GLImageDXGI> image_dxgi(
+      new gl::GLImageDXGI(texture_size, nullptr));
+  ASSERT_TRUE(image_dxgi->InitializeHandle(base::win::ScopedHandle(handle), 0,
+                                           gfx::BufferFormat::RGBA_8888));
 
   {
     ui::DCRendererLayerParams params;

gpu/ipc/service/gpu_memory_buffer_factory_dxgi.cc

@@ -106,11 +106,11 @@ GpuMemoryBufferFactoryDXGI::CreateImageForGpuMemoryBuffer(
     SurfaceHandle surface_handle) {
   if (handle.type != gfx::DXGI_SHARED_HANDLE)
     return nullptr;
-  // Transfer ownership of handle to GLImageDXGIHandle.
+  // Transfer ownership of handle to GLImageDXGI.
   base::win::ScopedHandle handle_owner;
   handle_owner.Set(handle.dxgi_handle.GetHandle());
-  auto image = base::MakeRefCounted<gl::GLImageDXGIHandle>(size, 0, format);
-  if (!image->Initialize(std::move(handle_owner)))
+  auto image = base::MakeRefCounted<gl::GLImageDXGI>(size, nullptr);
+  if (!image->InitializeHandle(std::move(handle_owner), 0, format))
     return nullptr;
   return image;
 }

ui/gl/gl_image_dxgi.cc

@@ -138,40 +138,97 @@ EGLSurface CreatePbuffer(const Microsoft::WRL::ComPtr<ID3D11Texture2D>& texture,
 
 }  // namespace
 
-GLImageDXGIBase::GLImageDXGIBase(const gfx::Size& size) : size_(size) {}
+GLImageDXGI::GLImageDXGI(const gfx::Size& size, EGLStreamKHR stream)
+    : size_(size), stream_(stream) {}
 
 // static
-GLImageDXGIBase* GLImageDXGIBase::FromGLImage(GLImage* image) {
+GLImageDXGI* GLImageDXGI::FromGLImage(GLImage* image) {
   if (!image || image->GetType() != Type::DXGI_IMAGE)
     return nullptr;
-  return static_cast<GLImageDXGIBase*>(image);
+  return static_cast<GLImageDXGI*>(image);
 }
 
-gfx::Size GLImageDXGIBase::GetSize() {
-  return size_;
+bool GLImageDXGI::BindTexImage(unsigned target) {
+  if (!handle_.Get())
+    return true;
+
+  DCHECK(texture_);
+  DCHECK(keyed_mutex_);
+  if (!SupportedBindFormat(buffer_format_))
+    return false;
+
+  // Lazy-initialize surface_, as it is only used for binding.
+  if (surface_ == EGL_NO_SURFACE) {
+    EGLConfig config = ChooseCompatibleConfig(buffer_format_);
+    if (!config)
+      return false;
+    surface_ = CreatePbuffer(texture_, buffer_format_, config, target);
+    if (surface_ == EGL_NO_SURFACE)
+      return false;
+  }
+
+  // We don't wait, just return immediately.
+  HRESULT hrWait = keyed_mutex_->AcquireSync(KEY_BIND, 0);
+
+  if (hrWait == WAIT_TIMEOUT || hrWait == WAIT_ABANDONED || FAILED(hrWait)) {
+    NOTREACHED();
+    return false;
+  }
+
+  return eglBindTexImage(gl::GLSurfaceEGL::GetHardwareDisplay(), surface_,
+                         EGL_BACK_BUFFER) == EGL_TRUE;
 }
 
-unsigned GLImageDXGIBase::GetInternalFormat() {
-  return GL_BGRA_EXT;
+bool GLImageDXGI::CopyTexImage(unsigned target) {
+  return false;
 }
 
-bool GLImageDXGIBase::BindTexImage(unsigned target) {
+bool GLImageDXGI::CopyTexSubImage(unsigned target,
+                                  const gfx::Point& offset,
+                                  const gfx::Rect& rect) {
   return false;
 }
 
-void GLImageDXGIBase::ReleaseTexImage(unsigned target) {}
+void GLImageDXGI::Flush() {}
 
-bool GLImageDXGIBase::CopyTexImage(unsigned target) {
-  return false;
+unsigned GLImageDXGI::GetInternalFormat() {
+  if (!handle_.Get())
+    return GL_BGRA_EXT;
+  else
+    return HasAlpha(buffer_format_) ? GL_RGBA : GL_RGB;
 }
 
-bool GLImageDXGIBase::CopyTexSubImage(unsigned target,
-                                      const gfx::Point& offset,
-                                      const gfx::Rect& rect) {
-  return false;
+gfx::Size GLImageDXGI::GetSize() {
+  return size_;
+}
+
+GLImage::Type GLImageDXGI::GetType() const {
+  return Type::DXGI_IMAGE;
+}
+
+void GLImageDXGI::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                               uint64_t process_tracing_id,
+                               const std::string& dump_name) {}
+
+void GLImageDXGI::ReleaseTexImage(unsigned target) {
+  if (!handle_.Get())
+    return;
+
+  DCHECK(texture_);
+  DCHECK(keyed_mutex_);
+
+  Microsoft::WRL::ComPtr<ID3D11Device> device =
+      QueryD3D11DeviceObjectFromANGLE();
+  Microsoft::WRL::ComPtr<ID3D11Device1> device1;
+  device.CopyTo(device1.GetAddressOf());
+
+  keyed_mutex_->ReleaseSync(KEY_RELEASE);
+
+  eglReleaseTexImage(gl::GLSurfaceEGL::GetHardwareDisplay(), surface_,
+                     EGL_BACK_BUFFER);
 }
 
-bool GLImageDXGIBase::ScheduleOverlayPlane(
+bool GLImageDXGI::ScheduleOverlayPlane(
     gfx::AcceleratedWidget widget,
     int z_order,
     gfx::OverlayTransform transform,
@@ -182,26 +239,36 @@ bool GLImageDXGIBase::ScheduleOverlayPlane(
   return false;
 }
 
-void GLImageDXGIBase::SetColorSpace(const gfx::ColorSpace& color_space) {
+void GLImageDXGI::SetColorSpace(const gfx::ColorSpace& color_space) {
   color_space_ = color_space;
 }
 
-void GLImageDXGIBase::Flush() {}
-
-void GLImageDXGIBase::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
-                                   uint64_t process_tracing_id,
-                                   const std::string& dump_name) {}
-
-GLImage::Type GLImageDXGIBase::GetType() const {
-  return Type::DXGI_IMAGE;
-}
+bool GLImageDXGI::InitializeHandle(base::win::ScopedHandle handle,
+                                   uint32_t level,
+                                   gfx::BufferFormat format) {
+  level_ = level;
+  buffer_format_ = format;
+  Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device =
+      QueryD3D11DeviceObjectFromANGLE();
+  if (!d3d11_device)
+    return false;
 
-GLImageDXGIBase::~GLImageDXGIBase() {}
+  Microsoft::WRL::ComPtr<ID3D11Device1> d3d11_device1;
+  if (FAILED(d3d11_device.CopyTo(d3d11_device1.GetAddressOf())))
+    return false;
 
-GLImageDXGI::GLImageDXGI(const gfx::Size& size, EGLStreamKHR stream)
-    : GLImageDXGIBase(size), stream_(stream) {}
+  if (FAILED(d3d11_device1->OpenSharedResource1(
+          handle.Get(), IID_PPV_ARGS(texture_.GetAddressOf())))) {
+    return false;
+  }
+  D3D11_TEXTURE2D_DESC desc;
+  texture_->GetDesc(&desc);
+  if (desc.ArraySize <= level_)
+    return false;
+  if (FAILED(texture_.CopyTo(keyed_mutex_.GetAddressOf())))
+    return false;
 
-bool GLImageDXGI::BindTexImage(unsigned target) {
+  handle_ = std::move(handle);
   return true;
 }
 
@@ -213,8 +280,14 @@ void GLImageDXGI::SetTexture(
 }
 
 GLImageDXGI::~GLImageDXGI() {
-  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
-  eglDestroyStreamKHR(egl_display, stream_);
+  if (handle_.Get()) {
+    if (surface_ != EGL_NO_SURFACE) {
+      eglDestroySurface(gl::GLSurfaceEGL::GetHardwareDisplay(), surface_);
+    }
+  } else if (stream_) {
+    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
+    eglDestroyStreamKHR(egl_display, stream_);
+  }
 }
 
 CopyingGLImageDXGI::CopyingGLImageDXGI(
@@ -343,89 +416,4 @@ bool CopyingGLImageDXGI::BindTexImage(unsigned target) {
 
 CopyingGLImageDXGI::~CopyingGLImageDXGI() {}
 
-GLImageDXGIHandle::~GLImageDXGIHandle() {
-  if (surface_ != EGL_NO_SURFACE) {
-    eglDestroySurface(gl::GLSurfaceEGL::GetHardwareDisplay(), surface_);
-  }
-}
-
-GLImageDXGIHandle::GLImageDXGIHandle(const gfx::Size& size,
-                                     uint32_t level,
-                                     gfx::BufferFormat format)
-    : GLImageDXGIBase(size), format_(format) {
-  level_ = level;
-}
-
-bool GLImageDXGIHandle::Initialize(base::win::ScopedHandle handle) {
-  Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device =
-      QueryD3D11DeviceObjectFromANGLE();
-  if (!d3d11_device)
-    return false;
-
-  Microsoft::WRL::ComPtr<ID3D11Device1> d3d11_device1;
-  if (FAILED(d3d11_device.CopyTo(d3d11_device1.GetAddressOf())))
-    return false;
-
-  if (FAILED(d3d11_device1->OpenSharedResource1(
-          handle.Get(), IID_PPV_ARGS(texture_.GetAddressOf())))) {
-    return false;
-  }
-  D3D11_TEXTURE2D_DESC desc;
-  texture_->GetDesc(&desc);
-  if (desc.ArraySize <= level_)
-    return false;
-  if (FAILED(texture_.CopyTo(keyed_mutex_.GetAddressOf())))
-    return false;
-
-  handle_ = std::move(handle);
-  return true;
-}
-
-unsigned GLImageDXGIHandle::GetInternalFormat() {
-  return HasAlpha(format_) ? GL_RGBA : GL_RGB;
-}
-
-bool GLImageDXGIHandle::BindTexImage(unsigned target) {
-  DCHECK(texture_);
-  DCHECK(keyed_mutex_);
-  if (!SupportedBindFormat(format_))
-    return false;
-
-  // Lazy-initialize surface_, as it is only used for binding.
-  if (surface_ == EGL_NO_SURFACE) {
-    EGLConfig config = ChooseCompatibleConfig(format_);
-    if (!config)
-      return false;
-    surface_ = CreatePbuffer(texture_, format_, config, target);
-    if (surface_ == EGL_NO_SURFACE)
-      return false;
-  }
-
-  // We don't wait, just return immediately.
-  HRESULT hrWait = keyed_mutex_->AcquireSync(KEY_BIND, 0);
-
-  if (hrWait == WAIT_TIMEOUT || hrWait == WAIT_ABANDONED || FAILED(hrWait)) {
-    NOTREACHED();
-    return false;
-  }
-
-  return eglBindTexImage(gl::GLSurfaceEGL::GetHardwareDisplay(), surface_,
-                         EGL_BACK_BUFFER) == EGL_TRUE;
-}
-
-void GLImageDXGIHandle::ReleaseTexImage(unsigned target) {
-  DCHECK(texture_);
-  DCHECK(keyed_mutex_);
-
-  Microsoft::WRL::ComPtr<ID3D11Device> device =
-      QueryD3D11DeviceObjectFromANGLE();
-  Microsoft::WRL::ComPtr<ID3D11Device1> device1;
-  device.CopyTo(device1.GetAddressOf());
-
-  keyed_mutex_->ReleaseSync(KEY_RELEASE);
-
-  eglReleaseTexImage(gl::GLSurfaceEGL::GetHardwareDisplay(), surface_,
-                     EGL_BACK_BUFFER);
-}
-
 }  // namespace gl

ui/gl/gl_image_dxgi.h

@@ -19,25 +19,27 @@ typedef void* EGLConfig;
 typedef void* EGLSurface;
 
 namespace gl {
-
-// TODO(776010): Reconcile the different GLImageDXGI types.  Remove
-// GLImageDXGIHandle, and move its implementation into GLImageDXGI.
-class GL_EXPORT GLImageDXGIBase : public GLImage {
+class GL_EXPORT GLImageDXGI : public GLImage {
  public:
-  GLImageDXGIBase(const gfx::Size& size);
+  GLImageDXGI(const gfx::Size& size, EGLStreamKHR stream);
 
   // Safe downcast. Returns nullptr on failure.
-  static GLImageDXGIBase* FromGLImage(GLImage* image);
+  static GLImageDXGI* FromGLImage(GLImage* image);
 
   // GLImage implementation.
-  gfx::Size GetSize() override;
-  unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
-  void ReleaseTexImage(unsigned target) override;
   bool CopyTexImage(unsigned target) override;
   bool CopyTexSubImage(unsigned target,
                        const gfx::Point& offset,
                        const gfx::Rect& rect) override;
+  void Flush() override;
+  unsigned GetInternalFormat() override;
+  gfx::Size GetSize() override;
+  Type GetType() const override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
+  void ReleaseTexImage(unsigned target) override;
   bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
                             gfx::OverlayTransform transform,
@@ -46,43 +48,30 @@ class GL_EXPORT GLImageDXGIBase : public GLImage {
                             bool enable_blend,
                             std::unique_ptr<gfx::GpuFence> gpu_fence) override;
   void SetColorSpace(const gfx::ColorSpace& color_space) override;
-  void Flush() override;
-  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
-                    uint64_t process_tracing_id,
-                    const std::string& dump_name) override;
-  Type GetType() const override;
 
-  Microsoft::WRL::ComPtr<ID3D11Texture2D> texture() { return texture_; }
   const gfx::ColorSpace& color_space() const { return color_space_; }
-
-  size_t level() const { return level_; }
   Microsoft::WRL::ComPtr<IDXGIKeyedMutex> keyed_mutex() { return keyed_mutex_; }
+  size_t level() const { return level_; }
+  Microsoft::WRL::ComPtr<ID3D11Texture2D> texture() { return texture_; }
 
- protected:
-  ~GLImageDXGIBase() override;
-
-  gfx::Size size_;
-  gfx::ColorSpace color_space_;
-
-  Microsoft::WRL::ComPtr<ID3D11Texture2D> texture_;
-  Microsoft::WRL::ComPtr<IDXGIKeyedMutex> keyed_mutex_;
-  size_t level_ = 0;
-};
-
-class GL_EXPORT GLImageDXGI : public GLImageDXGIBase {
- public:
-  GLImageDXGI(const gfx::Size& size, EGLStreamKHR stream);
-
-  // GLImage implementation.
-  bool BindTexImage(unsigned target) override;
-
+  bool InitializeHandle(base::win::ScopedHandle handle,
+                        uint32_t level,
+                        gfx::BufferFormat format);
   void SetTexture(const Microsoft::WRL::ComPtr<ID3D11Texture2D>& texture,
                   size_t level);
 
  protected:
   ~GLImageDXGI() override;
 
-  EGLStreamKHR stream_;
+  gfx::BufferFormat buffer_format_ = gfx::BufferFormat::BGRA_8888;
+  gfx::ColorSpace color_space_;
+  base::win::ScopedHandle handle_;
+  Microsoft::WRL::ComPtr<IDXGIKeyedMutex> keyed_mutex_;
+  size_t level_ = 0;
+  gfx::Size size_;
+  EGLSurface surface_ = nullptr;
+  EGLStreamKHR stream_ = nullptr;
+  Microsoft::WRL::ComPtr<ID3D11Texture2D> texture_;
 };
 
 // This copies to a new texture on bind.
@@ -114,27 +103,6 @@ class GL_EXPORT CopyingGLImageDXGI : public GLImageDXGI {
   Microsoft::WRL::ComPtr<ID3D11Texture2D> decoder_copy_texture_;
   Microsoft::WRL::ComPtr<ID3D11VideoProcessorOutputView> output_view_;
 };
-
-class GL_EXPORT GLImageDXGIHandle : public GLImageDXGIBase {
- public:
-  GLImageDXGIHandle(const gfx::Size& size,
-                    uint32_t level,
-                    gfx::BufferFormat format);
-
-  bool Initialize(base::win::ScopedHandle handle);
-
-  // GLImage implementation.
-  bool BindTexImage(unsigned target) override;
-  unsigned GetInternalFormat() override;
-  void ReleaseTexImage(unsigned target) override;
-
- protected:
-  ~GLImageDXGIHandle() override;
-
-  EGLSurface surface_ = nullptr;
-  base::win::ScopedHandle handle_;
-  gfx::BufferFormat format_;
-};
 }
 
 #endif  // UI_GL_GL_IMAGE_DXGI_H_

ui/gl/gl_image_dxgi_unittest.cc

@@ -66,9 +66,9 @@ class GLImageDXGITestDelegate : public GLImageTestDelegateBase {
         nullptr, &handle);
     EXPECT_HRESULT_SUCCEEDED(hr);
 
-    scoped_refptr<GLImageDXGIHandle> image(
-        new GLImageDXGIHandle(size, 0, format));
-    bool rv = image->Initialize(base::win::ScopedHandle(handle));
+    scoped_refptr<GLImageDXGI> image(new GLImageDXGI(size, nullptr));
+    bool rv =
+        image->InitializeHandle(base::win::ScopedHandle(handle), 0, format);
 
     EXPECT_TRUE(rv);
     return image;