ozone: Move the factory interfaces into a common target.

ui/ozone/platform/egltest/ozone_platform_egltest.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/ozone/platform/egltest/ozone_platform_egltest.h"
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "library_loaders/libeglplatform_shim.h"
-#include "ui/base/cursor/ozone/cursor_factory_ozone.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
-#include "ui/gfx/ozone/impl/file_surface_factory.h"
-#include "ui/gfx/ozone/surface_ozone_egl.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/ozone/ozone_platform.h"
 #include "ui/ozone/ozone_switches.h"
+#include "ui/ozone/platform/test/file_surface_factory.h"
+#include "ui/ozone/public/cursor_factory_ozone.h"
+#include "ui/ozone/public/surface_ozone_egl.h"
 
 #if defined(OS_CHROMEOS)
 #include "ui/ozone/common/chromeos/native_display_delegate_ozone.h"
 #include "ui/ozone/common/chromeos/touchscreen_device_manager_ozone.h"
 #endif
 
 #include <EGL/egl.h>
 
 namespace ui {
 
@@ skipping 10 matching lines @@
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->GetVar(kEglplatformShim, &library))
     return library;
   return kEglplatformShimDefault;
 }
 
 // EGL surface wrapper for libeglplatform_shim.
 //
 // This just manages the native window lifetime using
 // ShimGetNativeWindow & ShimReleaseNativeWindow.
-class SurfaceOzoneEgltest : public gfx::SurfaceOzoneEGL {
+class SurfaceOzoneEgltest : public SurfaceOzoneEGL {
  public:
   SurfaceOzoneEgltest(ShimNativeWindowId window_id,
                       LibeglplatformShimLoader* eglplatform_shim)
       : eglplatform_shim_(eglplatform_shim) {
     native_window_ = eglplatform_shim_->ShimGetNativeWindow(window_id);
   }
   virtual ~SurfaceOzoneEgltest() {
     CHECK(eglplatform_shim_->ShimReleaseNativeWindow(native_window_));
   }
 
@@ skipping 12 matching lines @@
  private:
   LibeglplatformShimLoader* eglplatform_shim_;
   intptr_t native_window_;
 };
 
 // EGL surface factory for libeglplatform_shim.
 //
 // This finds the right EGL/GLES2 libraries for loading, and creates
 // a single native window via ShimCreateWindow for drawing
 // into.
-class SurfaceFactoryEgltest : public gfx::SurfaceFactoryOzone {
+class SurfaceFactoryEgltest : public ui::SurfaceFactoryOzone {
  public:
   SurfaceFactoryEgltest(LibeglplatformShimLoader* eglplatform_shim)
       : eglplatform_shim_(eglplatform_shim), window_id_(SHIM_NO_WINDOW_ID) {}
   virtual ~SurfaceFactoryEgltest() { DestroySingleWindow(); }
 
   // Create the window.
   bool CreateSingleWindow();
   void DestroySingleWindow();
 
   // SurfaceFactoryOzone:
   virtual HardwareState InitializeHardware() OVERRIDE;
   virtual void ShutdownHardware() OVERRIDE;
   virtual intptr_t GetNativeDisplay() OVERRIDE;
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
-  virtual scoped_ptr<gfx::SurfaceOzoneEGL> CreateEGLSurfaceForWidget(
+  virtual scoped_ptr<SurfaceOzoneEGL> CreateEGLSurfaceForWidget(
       gfx::AcceleratedWidget widget) OVERRIDE;
   virtual const int32* GetEGLSurfaceProperties(
       const int32* desired_list) OVERRIDE;
   virtual bool LoadEGLGLES2Bindings(
       AddGLLibraryCallback add_gl_library,
       SetGLGetProcAddressProcCallback set_gl_get_proc_address) OVERRIDE;
 
  private:
   LibeglplatformShimLoader* eglplatform_shim_;
 
@@ skipping 22 matching lines @@
 intptr_t SurfaceFactoryEgltest::GetNativeDisplay() {
   return eglplatform_shim_->ShimGetNativeDisplay();
 }
 
 gfx::AcceleratedWidget SurfaceFactoryEgltest::GetAcceleratedWidget() {
   if (window_id_ == SHIM_NO_WINDOW_ID && !CreateSingleWindow())
     LOG(FATAL) << "failed to create window";
   return window_id_;
 }
 
-scoped_ptr<gfx::SurfaceOzoneEGL>
-SurfaceFactoryEgltest::CreateEGLSurfaceForWidget(
+scoped_ptr<SurfaceOzoneEGL> SurfaceFactoryEgltest::CreateEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
-  return make_scoped_ptr<gfx::SurfaceOzoneEGL>(
+  return make_scoped_ptr<SurfaceOzoneEGL>(
       new SurfaceOzoneEgltest(widget, eglplatform_shim_));
 }
 
 bool SurfaceFactoryEgltest::LoadEGLGLES2Bindings(
     AddGLLibraryCallback add_gl_library,
     SetGLGetProcAddressProcCallback set_gl_get_proc_address) {
   const char* egl_soname = eglplatform_shim_->ShimQueryString(SHIM_EGL_LIBRARY);
   const char* gles_soname =
       eglplatform_shim_->ShimQueryString(SHIM_GLES_LIBRARY);
   if (!egl_soname)
@@ skipping 74 matching lines @@
 
     LOG(FATAL) << "failed to load " << library;
   }
 
   void Initialize() {
     LoadShim();
     shim_initialized_ = eglplatform_shim_.ShimInitialize();
   }
 
   // OzonePlatform:
-  virtual gfx::SurfaceFactoryOzone* GetSurfaceFactoryOzone() OVERRIDE {
+  virtual ui::SurfaceFactoryOzone* GetSurfaceFactoryOzone() OVERRIDE {
     return surface_factory_ozone_.get();
   }
   virtual EventFactoryOzone* GetEventFactoryOzone() OVERRIDE {
     return event_factory_ozone_.get();
   }
   virtual CursorFactoryOzone* GetCursorFactoryOzone() OVERRIDE {
     return cursor_factory_ozone_.get();
   }
 
 #if defined(OS_CHROMEOS)
@@ skipping 34 matching lines @@
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformEgltest() {
   OzonePlatformEgltest* platform = new OzonePlatformEgltest;
   platform->Initialize();
   return platform;
 }
 
 }  // namespace ui