Convert Ozone cast to use GLOzone API.

ui/ozone/platform/cast/gl_ozone_egl_cast.cc

Index: ui/ozone/platform/cast/gl_ozone_egl_cast.cc
diff --git a/ui/ozone/platform/cast/surface_factory_cast.cc b/ui/ozone/platform/cast/gl_ozone_egl_cast.cc
similarity index 55%
copy from ui/ozone/platform/cast/surface_factory_cast.cc
copy to ui/ozone/platform/cast/gl_ozone_egl_cast.cc
index 04e3cfa125def513d357adb1a9c9daaa6d841b4e..44f86c61d3b8a8ab4e6e6b690b143a58f408d7c7 100644
--- a/ui/ozone/platform/cast/surface_factory_cast.cc
+++ b/ui/ozone/platform/cast/gl_ozone_egl_cast.cc
@@ -1,15 +1,14 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
+// 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 "ui/ozone/platform/cast/surface_factory_cast.h"
+#include "ui/ozone/platform/cast/gl_ozone_egl_cast.h"
 
 #include <EGL/egl.h>
 #include <dlfcn.h>
 
 #include <utility>
 
-#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ -17,12 +16,8 @@
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/public/cast_egl_platform.h"
 #include "chromecast/public/graphics_types.h"
-#include "third_party/skia/include/core/SkSurface.h"
-#include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/ozone/platform/cast/gl_surface_cast.h"
-#include "ui/ozone/public/native_pixmap.h"
-#include "ui/ozone/public/surface_ozone_canvas.h"
 
 using chromecast::CastEglPlatform;
 
@@ -54,54 +49,19 @@ gfx::Size GetDisplaySize() {
   return gfx::Size(1280, 720);
 }
 
-class DummySurface : public SurfaceOzoneCanvas {
- public:
-  DummySurface() {}
-  ~DummySurface() override {}
-
-  // SurfaceOzoneCanvas implementation:
-  sk_sp<SkSurface> GetSurface() override { return surface_; }
-
-  void ResizeCanvas(const gfx::Size& viewport_size) override {
-    surface_ = SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(
-        viewport_size.width(), viewport_size.height()));
-  }
-
-  void PresentCanvas(const gfx::Rect& damage) override {}
-
-  std::unique_ptr<gfx::VSyncProvider> CreateVSyncProvider() override {
-    return nullptr;
-  }
-
- private:
-  sk_sp<SkSurface> surface_;
-
-  DISALLOW_COPY_AND_ASSIGN(DummySurface);
-};
-
 }  // namespace
 
-SurfaceFactoryCast::SurfaceFactoryCast() : SurfaceFactoryCast(nullptr) {}
-
-SurfaceFactoryCast::SurfaceFactoryCast(
-    std::unique_ptr<CastEglPlatform> egl_platform)
-    : state_(kUninitialized),
-      display_type_(0),
-      have_display_type_(false),
-      window_(0),
-      display_size_(GetDisplaySize()),
-      egl_platform_(std::move(egl_platform)),
-      overlay_count_(0),
-      previous_frame_overlay_count_(0) {}
+GLOzoneEglCast::GLOzoneEglCast(std::unique_ptr<CastEglPlatform> egl_platform)
+    : display_size_(GetDisplaySize()), egl_platform_(std::move(egl_platform)) {}
 
-SurfaceFactoryCast::~SurfaceFactoryCast() {
+GLOzoneEglCast::~GLOzoneEglCast() {
   // eglTerminate must be called first on display before releasing resources
   // and shutting down hardware
   TerminateDisplay();
   ShutdownHardware();
 }
 
-void SurfaceFactoryCast::InitializeHardware() {
+void GLOzoneEglCast::InitializeHardware() {
   if (state_ == kInitialized) {
     return;
   }
@@ -115,7 +75,7 @@ void SurfaceFactoryCast::InitializeHardware() {
   }
 }
 
-void SurfaceFactoryCast::TerminateDisplay() {
+void GLOzoneEglCast::TerminateDisplay() {
   void* egl_lib_handle = egl_platform_->GetEglLibrary();
   if (!egl_lib_handle)
     return;
@@ -134,7 +94,7 @@ void SurfaceFactoryCast::TerminateDisplay() {
   DCHECK_EQ(terminate_result, static_cast<EGLBoolean>(EGL_TRUE));
 }
 
-void SurfaceFactoryCast::ShutdownHardware() {
+void GLOzoneEglCast::ShutdownHardware() {
   if (state_ != kInitialized)
     return;
 
@@ -145,7 +105,7 @@ void SurfaceFactoryCast::ShutdownHardware() {
   state_ = kUninitialized;
 }
 
-void SurfaceFactoryCast::OnSwapBuffers() {
+void GLOzoneEglCast::OnSwapBuffers() {
   DCHECK(overlay_count_ == 0 || overlay_count_ == 1);
 
   // Logging for overlays to help diagnose bugs when nothing is visible on
@@ -165,19 +125,13 @@ void SurfaceFactoryCast::OnSwapBuffers() {
   overlay_count_ = 0;
 }
 
-void SurfaceFactoryCast::OnOverlayScheduled(const gfx::Rect& display_bounds) {
+void GLOzoneEglCast::OnOverlayScheduled(const gfx::Rect& display_bounds) {
   ++overlay_count_;
   overlay_bounds_ = display_bounds;
 }
 
-scoped_refptr<gl::GLSurface> SurfaceFactoryCast::CreateViewGLSurface(
-    gl::GLImplementation implementation,
+scoped_refptr<gl::GLSurface> GLOzoneEglCast::CreateViewGLSurface(
     gfx::AcceleratedWidget widget) {
-  if (implementation != gl::kGLImplementationEGLGLES2) {
-    NOTREACHED();
-    return nullptr;
-  }
-
   // Verify requested widget dimensions match our current display size.
   DCHECK_EQ(widget >> 16, display_size_.width());
   DCHECK_EQ(widget & 0xffff, display_size_.height());
@@ -185,31 +139,17 @@ scoped_refptr<gl::GLSurface> SurfaceFactoryCast::CreateViewGLSurface(
   return gl::InitializeGLSurface(new GLSurfaceCast(widget, this));
 }
 
-scoped_refptr<gl::GLSurface> SurfaceFactoryCast::CreateOffscreenGLSurface(
-    gl::GLImplementation implementation,
+scoped_refptr<gl::GLSurface> GLOzoneEglCast::CreateOffscreenGLSurface(
     const gfx::Size& size) {
-  if (implementation != gl::kGLImplementationEGLGLES2) {
-    NOTREACHED();
-    return nullptr;
-  }
-
   return gl::InitializeGLSurface(new gl::PbufferGLSurfaceEGL(size));
 }
 
-std::unique_ptr<SurfaceOzoneCanvas> SurfaceFactoryCast::CreateCanvasForWidget(
-    gfx::AcceleratedWidget widget) {
-  // Software canvas support only in headless mode
-  if (egl_platform_)
-    return nullptr;
-  return base::WrapUnique<SurfaceOzoneCanvas>(new DummySurface());
-}
-
-intptr_t SurfaceFactoryCast::GetNativeDisplay() {
+intptr_t GLOzoneEglCast::GetNativeDisplay() {
   CreateDisplayTypeAndWindowIfNeeded();
   return reinterpret_cast<intptr_t>(display_type_);
 }
 
-void SurfaceFactoryCast::CreateDisplayTypeAndWindowIfNeeded() {
+void GLOzoneEglCast::CreateDisplayTypeAndWindowIfNeeded() {
   if (state_ == kUninitialized) {
     InitializeHardware();
   }
@@ -231,25 +171,25 @@ void SurfaceFactoryCast::CreateDisplayTypeAndWindowIfNeeded() {
   }
 }
 
-intptr_t SurfaceFactoryCast::GetNativeWindow() {
+intptr_t GLOzoneEglCast::GetNativeWindow() {
   CreateDisplayTypeAndWindowIfNeeded();
   return reinterpret_cast<intptr_t>(window_);
 }
 
-bool SurfaceFactoryCast::ResizeDisplay(gfx::Size size) {
+bool GLOzoneEglCast::ResizeDisplay(gfx::Size size) {
   DCHECK_EQ(size.width(), display_size_.width());
   DCHECK_EQ(size.height(), display_size_.height());
   return true;
 }
 
-void SurfaceFactoryCast::DestroyWindow() {
+void GLOzoneEglCast::DestroyWindow() {
   if (window_) {
     egl_platform_->DestroyWindow(window_);
     window_ = 0;
   }
 }
 
-void SurfaceFactoryCast::DestroyDisplayTypeAndWindow() {
+void GLOzoneEglCast::DestroyDisplayTypeAndWindow() {
   DestroyWindow();
   if (have_display_type_) {
     egl_platform_->DestroyDisplayType(display_type_);
@@ -258,60 +198,12 @@ void SurfaceFactoryCast::DestroyDisplayTypeAndWindow() {
   }
 }
 
-void SurfaceFactoryCast::ChildDestroyed() {
+void GLOzoneEglCast::ChildDestroyed() {
   if (egl_platform_->MultipleSurfaceUnsupported())
     DestroyWindow();
 }
 
-scoped_refptr<NativePixmap> SurfaceFactoryCast::CreateNativePixmap(
-    gfx::AcceleratedWidget widget,
-    gfx::Size size,
-    gfx::BufferFormat format,
-    gfx::BufferUsage usage) {
-  class CastPixmap : public NativePixmap {
-   public:
-    explicit CastPixmap(SurfaceFactoryCast* parent) : parent_(parent) {}
-
-    void* GetEGLClientBuffer() const override {
-      // TODO(halliwell): try to implement this through CastEglPlatform.
-      return nullptr;
-    }
-    bool AreDmaBufFdsValid() const override { return false; }
-    size_t GetDmaBufFdCount() const override { return 0; }
-    int GetDmaBufFd(size_t plane) const override { return -1; }
-    int GetDmaBufPitch(size_t plane) const override { return 0; }
-    int GetDmaBufOffset(size_t plane) const override { return 0; }
-    uint64_t GetDmaBufModifier(size_t plane) const override { return 0; }
-    gfx::BufferFormat GetBufferFormat() const override {
-      return gfx::BufferFormat::BGRA_8888;
-    }
-    gfx::Size GetBufferSize() const override { return gfx::Size(); }
-
-    bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                              int plane_z_order,
-                              gfx::OverlayTransform plane_transform,
-                              const gfx::Rect& display_bounds,
-                              const gfx::RectF& crop_rect) override {
-      parent_->OnOverlayScheduled(display_bounds);
-      return true;
-    }
-    void SetProcessingCallback(
-        const ProcessingCallback& processing_callback) override {}
-    gfx::NativePixmapHandle ExportHandle() override {
-      return gfx::NativePixmapHandle();
-    }
-
-   private:
-    ~CastPixmap() override {}
-
-    SurfaceFactoryCast* parent_;
-
-    DISALLOW_COPY_AND_ASSIGN(CastPixmap);
-  };
-  return make_scoped_refptr(new CastPixmap(this));
-}
-
-bool SurfaceFactoryCast::LoadEGLGLES2Bindings() {
+bool GLOzoneEglCast::LoadGLES2Bindings() {
   if (state_ != kInitialized) {
     InitializeHardware();
     if (state_ != kInitialized) {