Convert Ozone cast to directly create GLSurfaces.

ui/ozone/platform/cast/surface_factory_cast.cc

 // Copyright 2015 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 <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/surface_ozone_egl_cast.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);
@@ skipping 126 matching lines @@
   previous_frame_overlay_count_ = overlay_count_;
   previous_frame_overlay_bounds_ = overlay_bounds_;
   overlay_count_ = 0;
 }
 
 void SurfaceFactoryCast::OnOverlayScheduled(const gfx::Rect& display_bounds) {
   ++overlay_count_;
   overlay_bounds_ = display_bounds;
 }
 
+bool SurfaceFactoryCast::UseNewSurfaceAPI() {
+  return true;
+}
+
+scoped_refptr<gl::GLSurface> SurfaceFactoryCast::CreateViewGLSurface(
+    gl::GLImplementation implementation,
+    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,
+    const gfx::Size& size) {
+  if (implementation != gl::kGLImplementationEGLGLES2) {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  return gl::InitializeGLSurface(new gl::SurfacelessEGL(size));

[halliwell, 2016/07/27 14:34:18]

Is this right?  Currently we go through the pbuffer codepath for offscreen
surface.

[kylechar, 2016/07/27 14:39:49]

Oops. Good catch, I will upload the new patch for real this time.

+}
+
 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() {
   CreateDisplayTypeAndWindowIfNeeded();
@@ skipping 42 matching lines @@
 
 void SurfaceFactoryCast::DestroyDisplayTypeAndWindow() {
   DestroyWindow();
   if (have_display_type_) {
     egl_platform_->DestroyDisplayType(display_type_);
     display_type_ = 0;
     have_display_type_ = false;
   }
 }
 
-std::unique_ptr<SurfaceOzoneEGL> SurfaceFactoryCast::CreateEGLSurfaceForWidget(
-    gfx::AcceleratedWidget widget) {
-  // Verify requested widget dimensions match our current display size.
-  DCHECK_EQ(widget >> 16, display_size_.width());
-  DCHECK_EQ(widget & 0xffff, display_size_.height());
-  return base::WrapUnique<SurfaceOzoneEGL>(new SurfaceOzoneEglCast(this));
-}
-
 void SurfaceFactoryCast::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:
-    CastPixmap(SurfaceFactoryCast* parent) : parent_(parent) {}
+    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; }
@@ skipping 44 matching lines @@
     return false;
   }
 
   set_gl_get_proc_address.Run(gl_proc);
   add_gl_library.Run(lib_egl);
   add_gl_library.Run(lib_gles2);
   return true;
 }
 
 }  // namespace ui