Convert Ozone cast to use GLOzone API.

ui/ozone/platform/cast/gl_ozone_egl_cast.cc

-// 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"
 #include "base/strings/string_number_conversions.h"
 #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;
 
 namespace ui {
 
 namespace {
 
 typedef EGLDisplay (*EGLGetDisplayFn)(NativeDisplayType);
 typedef EGLBoolean (*EGLTerminateFn)(EGLDisplay);
 
@@ skipping 11 matching lines @@
       base::StringToInt(
           cmd_line->GetSwitchValueASCII(switches::kCastInitialScreenHeight),
           &height)) {
     return gfx::Size(width, height);
   }
   LOG(WARNING) << "Unable to get initial screen resolution from command line,"
                << "using default 720p";
   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) {}
+GLOzoneEglCast::GLOzoneEglCast(std::unique_ptr<CastEglPlatform> egl_platform)
+    : display_size_(GetDisplaySize()), egl_platform_(std::move(egl_platform)) {}
 
-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) {}
-
-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;
   }
   CHECK_EQ(state_, kUninitialized);
 
   if (egl_platform_->InitializeHardware()) {
     state_ = kInitialized;
   } else {
     ShutdownHardware();
     state_ = kFailed;
   }
 }
 
-void SurfaceFactoryCast::TerminateDisplay() {
+void GLOzoneEglCast::TerminateDisplay() {
   void* egl_lib_handle = egl_platform_->GetEglLibrary();
   if (!egl_lib_handle)
     return;
 
   EGLGetDisplayFn get_display =
       reinterpret_cast<EGLGetDisplayFn>(dlsym(egl_lib_handle, "eglGetDisplay"));
   EGLTerminateFn terminate =
       reinterpret_cast<EGLTerminateFn>(dlsym(egl_lib_handle, "eglTerminate"));
   DCHECK(get_display);
   DCHECK(terminate);
 
   EGLDisplay display = get_display(GetNativeDisplay());
   DCHECK_NE(display, EGL_NO_DISPLAY);
 
   EGLBoolean terminate_result = terminate(display);
   DCHECK_EQ(terminate_result, static_cast<EGLBoolean>(EGL_TRUE));
 }
 
-void SurfaceFactoryCast::ShutdownHardware() {
+void GLOzoneEglCast::ShutdownHardware() {
   if (state_ != kInitialized)
     return;
 
   DestroyDisplayTypeAndWindow();
 
   egl_platform_->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
   // screen.  Logging this every frame would be overwhelming, so we just
   // log on the transitions from 0 overlays -> 1 overlay and vice versa.
   if (overlay_count_ == 0 && previous_frame_overlay_count_ != 0) {
     LOG(INFO) << "Overlays deactivated";
   } else if (overlay_count_ != 0 && previous_frame_overlay_count_ == 0) {
     LOG(INFO) << "Overlays activated: " << overlay_bounds_.ToString();
   } else if (overlay_count_ == previous_frame_overlay_count_ &&
              overlay_bounds_ != previous_frame_overlay_bounds_) {
     LOG(INFO) << "Overlay geometry changed to " << overlay_bounds_.ToString();
   }
 
   previous_frame_overlay_count_ = overlay_count_;
   previous_frame_overlay_bounds_ = overlay_bounds_;
   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());
 
   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();
   }
   DCHECK_EQ(state_, kInitialized);
   if (!have_display_type_) {
     chromecast::Size create_size = FromGfxSize(display_size_);
     display_type_ = egl_platform_->CreateDisplayType(create_size);
     have_display_type_ = true;
   }
   if (!window_) {
     chromecast::Size create_size = FromGfxSize(display_size_);
     window_ = egl_platform_->CreateWindow(display_type_, create_size);
     if (!window_) {
       DestroyDisplayTypeAndWindow();
       state_ = kFailed;
       LOG(FATAL) << "Create EGLNativeWindowType(" << display_size_.ToString()
                  << ") failed.";
     }
   }
 }
 
-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_);
     display_type_ = 0;
     have_display_type_ = false;
   }
 }
 
-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) {
       return false;
     }
   }
 
   void* lib_egl = egl_platform_->GetEglLibrary();
   void* lib_gles2 = egl_platform_->GetGles2Library();
   gl::GLGetProcAddressProc gl_proc = reinterpret_cast<gl::GLGetProcAddressProc>(
       egl_platform_->GetGLProcAddressProc());
   if (!lib_egl || !lib_gles2 || !gl_proc) {
     return false;
   }
 
   gl::SetGLGetProcAddressProc(gl_proc);
   gl::AddGLNativeLibrary(lib_egl);
   gl::AddGLNativeLibrary(lib_gles2);
   return true;
 }
 
 }  // namespace ui