Rename "test" ozone platform to "headless"

ui/ozone/platform/eglheadless/ozone_platform_eglheadless.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 "ui/ozone/platform/eglheadless/ozone_platform_eglheadless.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/threading/thread_checker.h"
 #include "library_loaders/libeglplatform_shim.h"
 #include "third_party/khronos/EGL/egl.h"
 #include "ui/events/devices/device_data_manager.h"
@@ skipping 51 matching lines @@
       double ratio = std::sqrt(size.GetArea() / touchscreen_size.GetArea());
 
       event->set_location(location);
       event->set_radius_x(event->pointer_details().radius_x() * ratio);
       event->set_radius_y(event->pointer_details().radius_y() * ratio);
       return;
     }
   }
 }
 
-class EgltestWindow : public PlatformWindow, public PlatformEventDispatcher {
+class EglheadlessWindow : public PlatformWindow,
+                          public PlatformEventDispatcher {
  public:
-  EgltestWindow(PlatformWindowDelegate* delegate,
-                LibeglplatformShimLoader* eglplatform_shim,
-                EventFactoryEvdev* event_factory,
-                const gfx::Rect& bounds);
-  ~EgltestWindow() override;
+  EglheadlessWindow(PlatformWindowDelegate* delegate,
+                    LibeglplatformShimLoader* eglplatform_shim,
+                    EventFactoryEvdev* event_factory,
+                    const gfx::Rect& bounds);
+  ~EglheadlessWindow() override;
 
   // PlatformWindow:
   gfx::Rect GetBounds() override;
   void SetBounds(const gfx::Rect& bounds) override;
   void SetTitle(const base::string16& title) override;
   void Show() override;
   void Hide() override;
   void Close() override;
   void SetCapture() override;
   void ReleaseCapture() override;
@@ skipping 10 matching lines @@
   bool CanDispatchEvent(const PlatformEvent& event) override;
   uint32_t DispatchEvent(const PlatformEvent& event) override;
 
  private:
   PlatformWindowDelegate* delegate_;
   LibeglplatformShimLoader* eglplatform_shim_;
   EventFactoryEvdev* event_factory_;
   gfx::Rect bounds_;
   ShimNativeWindowId window_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(EgltestWindow);
+  DISALLOW_COPY_AND_ASSIGN(EglheadlessWindow);
 };
 
-EgltestWindow::EgltestWindow(PlatformWindowDelegate* delegate,
-                             LibeglplatformShimLoader* eglplatform_shim,
-                             EventFactoryEvdev* event_factory,
-                             const gfx::Rect& bounds)
+EglheadlessWindow::EglheadlessWindow(PlatformWindowDelegate* delegate,
+                                     LibeglplatformShimLoader* eglplatform_shim,
+                                     EventFactoryEvdev* event_factory,
+                                     const gfx::Rect& bounds)
     : delegate_(delegate),
       eglplatform_shim_(eglplatform_shim),
       event_factory_(event_factory),
       bounds_(bounds),
       window_id_(SHIM_NO_WINDOW_ID) {
   window_id_ = eglplatform_shim_->ShimCreateWindow();
   delegate_->OnAcceleratedWidgetAvailable(window_id_, 1.f);
   ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
 }
 
-EgltestWindow::~EgltestWindow() {
+EglheadlessWindow::~EglheadlessWindow() {
   ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   if (window_id_ != SHIM_NO_WINDOW_ID)
     eglplatform_shim_->ShimDestroyWindow(window_id_);
 }
 
-gfx::Rect EgltestWindow::GetBounds() {
+gfx::Rect EglheadlessWindow::GetBounds() {
   return bounds_;
 }
 
-void EgltestWindow::SetBounds(const gfx::Rect& bounds) {
+void EglheadlessWindow::SetBounds(const gfx::Rect& bounds) {
   bounds_ = bounds;
   delegate_->OnBoundsChanged(bounds);
 }
 
-void EgltestWindow::SetTitle(const base::string16& title) {
-}
+void EglheadlessWindow::SetTitle(const base::string16& title) {}
 
-void EgltestWindow::Show() {
-}
+void EglheadlessWindow::Show() {}
 
-void EgltestWindow::Hide() {
-}
+void EglheadlessWindow::Hide() {}
 
-void EgltestWindow::Close() {
-}
+void EglheadlessWindow::Close() {}
 
-void EgltestWindow::SetCapture() {
-}
+void EglheadlessWindow::SetCapture() {}
 
-void EgltestWindow::ReleaseCapture() {
-}
+void EglheadlessWindow::ReleaseCapture() {}
 
-void EgltestWindow::ToggleFullscreen() {
-}
+void EglheadlessWindow::ToggleFullscreen() {}
 
-void EgltestWindow::Maximize() {
-}
+void EglheadlessWindow::Maximize() {}
 
-void EgltestWindow::Minimize() {
-}
+void EglheadlessWindow::Minimize() {}
 
-void EgltestWindow::Restore() {
-}
+void EglheadlessWindow::Restore() {}
 
-void EgltestWindow::SetCursor(PlatformCursor cursor) {
-}
+void EglheadlessWindow::SetCursor(PlatformCursor cursor) {}
 
-void EgltestWindow::MoveCursorTo(const gfx::Point& location) {
+void EglheadlessWindow::MoveCursorTo(const gfx::Point& location) {
   event_factory_->WarpCursorTo(window_id_, location);
 }
 
-void EgltestWindow::ConfineCursorToBounds(const gfx::Rect& bounds) {
-}
+void EglheadlessWindow::ConfineCursorToBounds(const gfx::Rect& bounds) {}
 
-PlatformImeController* EgltestWindow::GetPlatformImeController() {
+PlatformImeController* EglheadlessWindow::GetPlatformImeController() {
   return nullptr;
 }
 
-bool EgltestWindow::CanDispatchEvent(const ui::PlatformEvent& ne) {
+bool EglheadlessWindow::CanDispatchEvent(const ui::PlatformEvent& ne) {
   return true;
 }
 
-uint32_t EgltestWindow::DispatchEvent(const ui::PlatformEvent& native_event) {
+uint32_t EglheadlessWindow::DispatchEvent(
+    const ui::PlatformEvent& native_event) {
   DCHECK(native_event);
   Event* event = static_cast<Event*>(native_event);
   if (event->IsTouchEvent()) {
     ScaleTouchEvent(static_cast<TouchEvent*>(event),
                     gfx::SizeF(bounds_.size()));
   }
 
   DispatchEventFromNativeUiEvent(
       native_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
                                base::Unretained(delegate_)));
 
   return ui::POST_DISPATCH_STOP_PROPAGATION;
 }
 
 // EGL surface wrapper for libeglplatform_shim.
 //
 // This just manages the native window lifetime using
 // ShimGetNativeWindow & ShimReleaseNativeWindow.
-class SurfaceOzoneEgltest : public SurfaceOzoneEGL {
+class SurfaceOzoneEglheadless : public SurfaceOzoneEGL {
  public:
-  SurfaceOzoneEgltest(ShimNativeWindowId window_id,
-                      LibeglplatformShimLoader* eglplatform_shim)
+  SurfaceOzoneEglheadless(ShimNativeWindowId window_id,
+                          LibeglplatformShimLoader* eglplatform_shim)
       : eglplatform_shim_(eglplatform_shim) {
     native_window_ = eglplatform_shim_->ShimGetNativeWindow(window_id);
   }
-  ~SurfaceOzoneEgltest() override {
+  ~SurfaceOzoneEglheadless() override {
     bool ret = eglplatform_shim_->ShimReleaseNativeWindow(native_window_);
     DCHECK(ret);
   }
 
   intptr_t GetNativeWindow() override { return native_window_; }
 
   bool OnSwapBuffers() override { return true; }
 
   bool OnSwapBuffersAsync(const SwapCompletionCallback& callback) override {
     callback.Run(gfx::SwapResult::SWAP_ACK);
@@ skipping 11 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 ui::SurfaceFactoryOzone {
+class SurfaceFactoryEglheadless : public ui::SurfaceFactoryOzone {
  public:
-  SurfaceFactoryEgltest(LibeglplatformShimLoader* eglplatform_shim)
+  SurfaceFactoryEglheadless(LibeglplatformShimLoader* eglplatform_shim)
       : eglplatform_shim_(eglplatform_shim) {}
-  ~SurfaceFactoryEgltest() override {
+  ~SurfaceFactoryEglheadless() override {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
   // SurfaceFactoryOzone:
   intptr_t GetNativeDisplay() override;
   scoped_ptr<SurfaceOzoneEGL> CreateEGLSurfaceForWidget(
       gfx::AcceleratedWidget widget) override;
   const int32* GetEGLSurfaceProperties(const int32* desired_list) override;
   bool LoadEGLGLES2Bindings(
       AddGLLibraryCallback add_gl_library,
       SetGLGetProcAddressProcCallback set_gl_get_proc_address) override;
 
  private:
   LibeglplatformShimLoader* eglplatform_shim_;
   base::ThreadChecker thread_checker_;
 };
 
-intptr_t SurfaceFactoryEgltest::GetNativeDisplay() {
+intptr_t SurfaceFactoryEglheadless::GetNativeDisplay() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return eglplatform_shim_->ShimGetNativeDisplay();
 }
 
-scoped_ptr<SurfaceOzoneEGL> SurfaceFactoryEgltest::CreateEGLSurfaceForWidget(
+scoped_ptr<SurfaceOzoneEGL>
+SurfaceFactoryEglheadless::CreateEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return make_scoped_ptr<SurfaceOzoneEGL>(
-      new SurfaceOzoneEgltest(widget, eglplatform_shim_));
+      new SurfaceOzoneEglheadless(widget, eglplatform_shim_));
 }
 
-bool SurfaceFactoryEgltest::LoadEGLGLES2Bindings(
+bool SurfaceFactoryEglheadless::LoadEGLGLES2Bindings(
     AddGLLibraryCallback add_gl_library,
     SetGLGetProcAddressProcCallback set_gl_get_proc_address) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const char* egl_soname = eglplatform_shim_->ShimQueryString(SHIM_EGL_LIBRARY);
   const char* gles_soname =
       eglplatform_shim_->ShimQueryString(SHIM_GLES_LIBRARY);
   if (!egl_soname)
     egl_soname = kDefaultEglSoname;
   if (!gles_soname)
     gles_soname = kDefaultGlesSoname;
 
   return ::ui::LoadEGLGLES2Bindings(add_gl_library, set_gl_get_proc_address,
                                     egl_soname, gles_soname);
 }
 
-const int32* SurfaceFactoryEgltest::GetEGLSurfaceProperties(
+const int32* SurfaceFactoryEglheadless::GetEGLSurfaceProperties(
     const int32* desired_list) {
   DCHECK(thread_checker_.CalledOnValidThread());
   static const int32 broken_props[] = {
       EGL_RENDERABLE_TYPE,
       EGL_OPENGL_ES2_BIT,
       EGL_SURFACE_TYPE,
       EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
       EGL_NONE,
   };
   return broken_props;
 }
 
 // Test platform for EGL.
 //
 // This is a tiny EGL-based platform. Creation of the native window is
 // handled by a separate library called eglplatform_shim.so.1 because
 // this itself is platform specific and we want to test out multiple
 // hardware platforms.
-class OzonePlatformEgltest : public OzonePlatform {
+class OzonePlatformEglheadless : public OzonePlatform {
  public:
-  OzonePlatformEgltest() : shim_initialized_(false) {}
-  ~OzonePlatformEgltest() override {
+  OzonePlatformEglheadless() : shim_initialized_(false) {}
+  ~OzonePlatformEglheadless() override {
     if (shim_initialized_)
       eglplatform_shim_.ShimTerminate();
   }
 
   void LoadShim() {
     std::string library = GetShimLibraryName();
 
     if (eglplatform_shim_.Load(library))
       return;
 
@@ skipping 31 matching lines @@
   }
   GpuPlatformSupportHost* GetGpuPlatformSupportHost() override {
     return gpu_platform_support_host_.get();
   }
   scoped_ptr<SystemInputInjector> CreateSystemInputInjector() override {
     return nullptr;  // no input injection support.
   }
   scoped_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
       const gfx::Rect& bounds) override {
-    return make_scoped_ptr<PlatformWindow>(new EgltestWindow(
+    return make_scoped_ptr<PlatformWindow>(new EglheadlessWindow(
         delegate, &eglplatform_shim_, event_factory_ozone_.get(), bounds));
   }
   scoped_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate() override {
     return make_scoped_ptr(new NativeDisplayDelegateOzone());
   }
   base::ScopedFD OpenClientNativePixmapDevice() const override {
     return base::ScopedFD();
   }
 
   void InitializeUI() override {
     device_manager_ = CreateDeviceManager();
     overlay_manager_.reset(new StubOverlayManager());
     KeyboardLayoutEngineManager::SetKeyboardLayoutEngine(
         make_scoped_ptr(new StubKeyboardLayoutEngine()));
     event_factory_ozone_.reset(new EventFactoryEvdev(
         NULL, device_manager_.get(),
         KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()));
     cursor_factory_ozone_.reset(new CursorFactoryOzone());
     gpu_platform_support_host_.reset(CreateStubGpuPlatformSupportHost());
   }
 
   void InitializeGPU() override {
-    surface_factory_ozone_.reset(new SurfaceFactoryEgltest(&eglplatform_shim_));
+    surface_factory_ozone_.reset(
+        new SurfaceFactoryEglheadless(&eglplatform_shim_));
     gpu_platform_support_.reset(CreateStubGpuPlatformSupport());
   }
 
  private:
   LibeglplatformShimLoader eglplatform_shim_;
   scoped_ptr<DeviceManager> device_manager_;
-  scoped_ptr<SurfaceFactoryEgltest> surface_factory_ozone_;
+  scoped_ptr<SurfaceFactoryEglheadless> surface_factory_ozone_;
   scoped_ptr<EventFactoryEvdev> event_factory_ozone_;
   scoped_ptr<CursorFactoryOzone> cursor_factory_ozone_;
   scoped_ptr<GpuPlatformSupport> gpu_platform_support_;
   scoped_ptr<GpuPlatformSupportHost> gpu_platform_support_host_;
   scoped_ptr<OverlayManagerOzone> overlay_manager_;
 
   bool shim_initialized_;
 
-  DISALLOW_COPY_AND_ASSIGN(OzonePlatformEgltest);
+  DISALLOW_COPY_AND_ASSIGN(OzonePlatformEglheadless);
 };
 
 }  // namespace
 
-OzonePlatform* CreateOzonePlatformEgltest() {
-  OzonePlatformEgltest* platform = new OzonePlatformEgltest;
+OzonePlatform* CreateOzonePlatformEglheadless() {
+  OzonePlatformEglheadless* platform = new OzonePlatformEglheadless;
   platform->Initialize();
   return platform;
 }
 
 }  // namespace ui