ozone: Remove singleton pattern for SurfaceFactoryOzone.

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/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/worker_pool.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_image_linux_dma_buffer.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 #include "ui/ozone/public/native_pixmap.h"
+#include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
 namespace gfx {
 
 namespace {
 
 void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
   eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                        EGL_FOREVER_KHR);
@@ skipping 75 matching lines @@
 
 bool GLSurfaceOzoneEGL::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(new ui::ScopedMakeCurrent(current_context, this));
   }
 
   Destroy();
-  ozone_surface_ = ui::SurfaceFactoryOzone::GetInstance()
+  ozone_surface_ = ui::OzonePlatform::GetInstance()
+                       ->GetSurfaceFactoryOzone()
                        ->CreateEGLSurfaceForWidget(widget_)
                        .Pass();
   if (!ozone_surface_) {
     LOG(ERROR) << "Failed to create native surface.";
     return false;
   }
 
   window_ = ozone_surface_->GetNativeWindow();
   if (!Initialize()) {
     LOG(ERROR) << "Failed to initialize.";
@@ skipping 339 matching lines @@
     return false;
   pixmap_ = pixmap;
   return true;
 }
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::ScheduleOverlayPlane(
     gfx::AcceleratedWidget widget,
     int z_order,
     gfx::OverlayTransform transform,
     const gfx::Rect& bounds_rect,
     const gfx::RectF& crop_rect) {
-  return ui::SurfaceFactoryOzone::GetInstance()->ScheduleOverlayPlane(
-      widget, z_order, transform, pixmap_, bounds_rect, crop_rect);
+  return ui::OzonePlatform::GetInstance()
+      ->GetSurfaceFactoryOzone()
+      ->ScheduleOverlayPlane(widget, z_order, transform, pixmap_, bounds_rect,
+                             crop_rect);
 }
 
 GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::~SurfaceImage() {
 }
 
 GLSurfaceOzoneSurfacelessSurfaceImpl::GLSurfaceOzoneSurfacelessSurfaceImpl(
     scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     AcceleratedWidget widget)
     : GLSurfaceOzoneSurfaceless(ozone_surface.Pass(), widget),
       fbo_(0),
@@ skipping 84 matching lines @@
   ScopedFrameBufferBinder fb(fbo_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                             textures_[current_surface_], 0);
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::CreatePixmaps() {
   if (!fbo_)
     return true;
   for (size_t i = 0; i < arraysize(textures_); i++) {
     scoped_refptr<ui::NativePixmap> pixmap =
-        ui::SurfaceFactoryOzone::GetInstance()->CreateNativePixmap(
-            widget_, GetSize(), ui::SurfaceFactoryOzone::BGRA_8888,
-            ui::SurfaceFactoryOzone::SCANOUT);
+        ui::OzonePlatform::GetInstance()
+            ->GetSurfaceFactoryOzone()
+            ->CreateNativePixmap(widget_, GetSize(),
+                                 ui::SurfaceFactoryOzone::BGRA_8888,
+                                 ui::SurfaceFactoryOzone::SCANOUT);
     if (!pixmap)
       return false;
     scoped_refptr<SurfaceImage> image =
         new SurfaceImage(GetSize(), GL_BGRA_EXT);
     if (!image->Initialize(pixmap, gfx::GpuMemoryBuffer::Format::BGRA_8888))
       return false;
     images_[i] = image;
     // Bind image to texture.
     ScopedTextureBinder binder(GL_TEXTURE_2D, textures_[i]);
     if (!images_[i]->BindTexImage(GL_TEXTURE_2D))
@@ skipping 21 matching lines @@
       return false;
   }
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateSurfacelessViewGLSurface(
     gfx::AcceleratedWidget window) {
   if (GetGLImplementation() == kGLImplementationEGLGLES2 &&
       window != kNullAcceleratedWidget &&
       GLSurfaceEGL::IsEGLSurfacelessContextSupported() &&
-      ui::SurfaceFactoryOzone::GetInstance()->CanShowPrimaryPlaneAsOverlay()) {
+      ui::OzonePlatform::GetInstance()
+          ->GetSurfaceFactoryOzone()
+          ->CanShowPrimaryPlaneAsOverlay()) {
     scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
-        ui::SurfaceFactoryOzone::GetInstance()
+        ui::OzonePlatform::GetInstance()
+            ->GetSurfaceFactoryOzone()
             ->CreateSurfacelessEGLSurfaceForWidget(window);
     if (!surface_ozone)
       return nullptr;
     scoped_refptr<GLSurface> surface;
     surface = new GLSurfaceOzoneSurfaceless(surface_ozone.Pass(), window);
     if (surface->Initialize())
       return surface;
   }
 
   return nullptr;
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
     gfx::AcceleratedWidget window) {
   if (GetGLImplementation() == kGLImplementationOSMesaGL) {
     scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
     if (!surface->Initialize())
       return NULL;
     return surface;
   }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
   if (window != kNullAcceleratedWidget) {
     scoped_refptr<GLSurface> surface;
     if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() &&
-        ui::SurfaceFactoryOzone::GetInstance()
+        ui::OzonePlatform::GetInstance()
+            ->GetSurfaceFactoryOzone()
             ->CanShowPrimaryPlaneAsOverlay()) {
       scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
-          ui::SurfaceFactoryOzone::GetInstance()
+          ui::OzonePlatform::GetInstance()
+              ->GetSurfaceFactoryOzone()
               ->CreateSurfacelessEGLSurfaceForWidget(window);
       if (!surface_ozone)
         return NULL;
       surface = new GLSurfaceOzoneSurfacelessSurfaceImpl(surface_ozone.Pass(),
                                                          window);
     } else {
       scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
-          ui::SurfaceFactoryOzone::GetInstance()->CreateEGLSurfaceForWidget(
-              window);
+          ui::OzonePlatform::GetInstance()
+              ->GetSurfaceFactoryOzone()
+              ->CreateEGLSurfaceForWidget(window);
       if (!surface_ozone)
         return NULL;
 
       surface = new GLSurfaceOzoneEGL(surface_ozone.Pass(), window);
     }
     if (!surface->Initialize())
       return NULL;
     return surface;
   } else {
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
@@ skipping 29 matching lines @@
     }
     case kGLImplementationMockGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
-  return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
+  return ui::OzonePlatform::GetInstance()
+      ->GetSurfaceFactoryOzone()
+      ->GetNativeDisplay();
 }
 
 }  // namespace gfx