Roll Chrome into Mojo.

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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/gl/gl_surface.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_context.h"
@@ skipping 12 matching lines @@
 
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     AcceleratedWidget widget)
       : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()),
         ozone_surface_(ozone_surface.Pass()),
         widget_(widget) {}
 
-  virtual bool Initialize() override {
+  bool Initialize() override {
     return Initialize(ozone_surface_->CreateVSyncProvider());
   }
-  virtual bool Resize(const gfx::Size& size) override {
+  bool Resize(const gfx::Size& size) override {
     if (!ozone_surface_->ResizeNativeWindow(size)) {
       if (!ReinitializeNativeSurface() ||
           !ozone_surface_->ResizeNativeWindow(size))
         return false;
     }
 
     return NativeViewGLSurfaceEGL::Resize(size);
   }
-  virtual bool SwapBuffers() override {
+  bool SwapBuffers() override {
     if (!NativeViewGLSurfaceEGL::SwapBuffers())
       return false;
 
     return ozone_surface_->OnSwapBuffers();
   }
-  virtual bool ScheduleOverlayPlane(int z_order,
-                                    OverlayTransform transform,
-                                    GLImage* image,
-                                    const Rect& bounds_rect,
-                                    const RectF& crop_rect) override {
+  bool ScheduleOverlayPlane(int z_order,
+                            OverlayTransform transform,
+                            GLImage* image,
+                            const Rect& bounds_rect,
+                            const RectF& crop_rect) override {
     return image->ScheduleOverlayPlane(
         widget_, z_order, transform, bounds_rect, crop_rect);
   }
 
  private:
   using NativeViewGLSurfaceEGL::Initialize;
 
-  virtual ~GLSurfaceOzoneEGL() {
+  ~GLSurfaceOzoneEGL() override {
     Destroy();  // EGL surface must be destroyed before SurfaceOzone
   }
 
   bool ReinitializeNativeSurface() {
     scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
     GLContext* current_context = GLContext::GetCurrent();
     bool was_current =
         current_context && current_context->IsCurrent(this);
     if (was_current) {
       scoped_make_current.reset(
@@ skipping 26 matching lines @@
 };
 
 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
  public:
   GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                             AcceleratedWidget widget)
       : SurfacelessEGL(gfx::Size()),
         ozone_surface_(ozone_surface.Pass()),
         widget_(widget) {}
 
-  virtual bool Initialize() override {
+  bool Initialize() override {
     if (!SurfacelessEGL::Initialize())
       return false;
     vsync_provider_ = ozone_surface_->CreateVSyncProvider();
     if (!vsync_provider_)
       return false;
     return true;
   }
-  virtual bool Resize(const gfx::Size& size) override {
+  bool Resize(const gfx::Size& size) override {
     if (!ozone_surface_->ResizeNativeWindow(size))
       return false;
 
     return SurfacelessEGL::Resize(size);
   }
-  virtual bool SwapBuffers() override {
+  bool SwapBuffers() override {
     // TODO: this should be replaced by a fence when supported by the driver.
     glFlush();
     return ozone_surface_->OnSwapBuffers();
   }
-  virtual bool ScheduleOverlayPlane(int z_order,
-                                    OverlayTransform transform,
-                                    GLImage* image,
-                                    const Rect& bounds_rect,
-                                    const RectF& crop_rect) override {
+  bool ScheduleOverlayPlane(int z_order,
+                            OverlayTransform transform,
+                            GLImage* image,
+                            const Rect& bounds_rect,
+                            const RectF& crop_rect) override {
     return image->ScheduleOverlayPlane(
         widget_, z_order, transform, bounds_rect, crop_rect);
   }
-  virtual bool IsOffscreen() override { return false; }
-  virtual VSyncProvider* GetVSyncProvider() override {
-    return vsync_provider_.get();
-  }
-  virtual bool SupportsPostSubBuffer() override { return true; }
-  virtual bool PostSubBuffer(int x, int y, int width, int height) override {
+  bool IsOffscreen() override { return false; }
+  VSyncProvider* GetVSyncProvider() override { return vsync_provider_.get(); }
+  bool SupportsPostSubBuffer() override { return true; }
+  bool PostSubBuffer(int x, int y, int width, int height) override {
     // The actual sub buffer handling is handled at higher layers.
     SwapBuffers();
     return true;
   }
+  bool SwapBuffersAsync(const SwapCompletionCallback& callback) override {
+    // TODO: this should be replaced by a fence when supported by the driver.
+    glFlush();
+    return ozone_surface_->OnSwapBuffersAsync(callback);
+  }
+  bool PostSubBufferAsync(int x,
+                          int y,
+                          int width,
+                          int height,
+                          const SwapCompletionCallback& callback) override {
+    return SwapBuffersAsync(callback);
+  }
 
  private:
-  virtual ~GLSurfaceOzoneSurfaceless() {
+  ~GLSurfaceOzoneSurfaceless() override {
     Destroy();  // EGL surface must be destroyed before SurfaceOzone
   }
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   AcceleratedWidget widget_;
   scoped_ptr<VSyncProvider> vsync_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 };
@@ skipping 87 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx