ozone: egltest: Convert to PlatformWindow

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/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
+#include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/gfx/vsync_provider.h"
-#include "ui/ozone/common/window/platform_window_compat.h"
 #include "ui/ozone/public/cursor_factory_ozone.h"
 #include "ui/ozone/public/gpu_platform_support.h"
 #include "ui/ozone/public/gpu_platform_support_host.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/ozone_switches.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
+#include "ui/platform_window/platform_window.h"
+#include "ui/platform_window/platform_window_delegate.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 {
 
 namespace {
 
 const char kEglplatformShim[] = "EGLPLATFORM_SHIM";
 const char kEglplatformShimDefault[] = "libeglplatform_shim.so.1";
 const char kDefaultEglSoname[] = "libEGL.so.1";
 const char kDefaultGlesSoname[] = "libGLESv2.so.2";
 
 // Get the library soname to load.
 std::string GetShimLibraryName() {
   std::string library;
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->GetVar(kEglplatformShim, &library))
     return library;
   return kEglplatformShimDefault;
 }
 
+class EgltestWindow : public PlatformWindow, public PlatformEventDispatcher {
+ public:
+  EgltestWindow(PlatformWindowDelegate* delegate,
+                LibeglplatformShimLoader* eglplatform_shim,
+                const gfx::Rect& bounds);
+  virtual ~EgltestWindow();
+
+  // PlatformWindow:
+  virtual gfx::Rect GetBounds() OVERRIDE;
+  virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
+  virtual void Show() OVERRIDE;
+  virtual void Hide() OVERRIDE;
+  virtual void Close() OVERRIDE;
+  virtual void SetCapture() OVERRIDE;
+  virtual void ReleaseCapture() OVERRIDE;
+  virtual void ToggleFullscreen() OVERRIDE;
+  virtual void Maximize() OVERRIDE;
+  virtual void Minimize() OVERRIDE;
+  virtual void Restore() OVERRIDE;
+
+  // PlatformEventDispatcher:
+  virtual bool CanDispatchEvent(const PlatformEvent& event) OVERRIDE;
+  virtual uint32_t DispatchEvent(const PlatformEvent& event) OVERRIDE;
+
+ private:
+  PlatformWindowDelegate* delegate_;
+  LibeglplatformShimLoader* eglplatform_shim_;
+  gfx::Rect bounds_;
+  ShimNativeWindowId window_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(EgltestWindow);
+};
+
+EgltestWindow::EgltestWindow(PlatformWindowDelegate* delegate,
+                             LibeglplatformShimLoader* eglplatform_shim,
+                             const gfx::Rect& bounds)
+    : delegate_(delegate),
+      eglplatform_shim_(eglplatform_shim),
+      bounds_(bounds),
+      window_id_(SHIM_NO_WINDOW_ID) {
+  window_id_ = eglplatform_shim_->ShimCreateWindow();
+  delegate_->OnAcceleratedWidgetAvailable(window_id_);
+  ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
+}
+
+EgltestWindow::~EgltestWindow() {
+  ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
+  if (window_id_ != SHIM_NO_WINDOW_ID)
+    eglplatform_shim_->ShimDestroyWindow(window_id_);
+}
+
+gfx::Rect EgltestWindow::GetBounds() {
+  return bounds_;
+}
+
+void EgltestWindow::SetBounds(const gfx::Rect& bounds) {
+  bounds_ = bounds;
+  delegate_->OnBoundsChanged(bounds);
+}
+
+void EgltestWindow::Show() {
+}
+
+void EgltestWindow::Hide() {
+}
+
+void EgltestWindow::Close() {
+}
+
+void EgltestWindow::SetCapture() {
+}
+
+void EgltestWindow::ReleaseCapture() {
+}
+
+void EgltestWindow::ToggleFullscreen() {
+}
+
+void EgltestWindow::Maximize() {
+}
+
+void EgltestWindow::Minimize() {
+}
+
+void EgltestWindow::Restore() {
+}
+
+bool EgltestWindow::CanDispatchEvent(const ui::PlatformEvent& ne) {
+  return true;
+}
+
+uint32_t EgltestWindow::DispatchEvent(const ui::PlatformEvent& ne) {
+  ui::Event* event = static_cast<ui::Event*>(ne);
+  delegate_->DispatchEvent(event);
+  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 {
  public:
   SurfaceOzoneEgltest(ShimNativeWindowId window_id,
                       LibeglplatformShimLoader* eglplatform_shim)
       : eglplatform_shim_(eglplatform_shim) {
     native_window_ = eglplatform_shim_->ShimGetNativeWindow(window_id);
@@ skipping 28 matching lines @@
 };
 
 // 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 {
  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();
+      : eglplatform_shim_(eglplatform_shim) {}
+  virtual ~SurfaceFactoryEgltest() {}
 
   // SurfaceFactoryOzone:
   virtual HardwareState InitializeHardware() OVERRIDE;
   virtual void ShutdownHardware() OVERRIDE;
   virtual intptr_t GetNativeDisplay() OVERRIDE;
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
   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_;
-
-  // TODO(spang): Remove once we have a windowing API. This limits to 1 window.
-  ShimNativeWindowId window_id_;
 };
 
-bool SurfaceFactoryEgltest::CreateSingleWindow() {
-  window_id_ = eglplatform_shim_->ShimCreateWindow();
-  return (window_id_ != SHIM_NO_WINDOW_ID);
-}
-
-void SurfaceFactoryEgltest::DestroySingleWindow() {
-  if (window_id_ != SHIM_NO_WINDOW_ID)
-    CHECK(eglplatform_shim_->ShimDestroyWindow(window_id_));
-}
-
 SurfaceFactoryEgltest::HardwareState
 SurfaceFactoryEgltest::InitializeHardware() {
   return INITIALIZED;
 }
 
 void SurfaceFactoryEgltest::ShutdownHardware() {
 }
 
 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_;
+  NOTREACHED();
+  return gfx::kNullAcceleratedWidget;
 }
 
 scoped_ptr<SurfaceOzoneEGL> SurfaceFactoryEgltest::CreateEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
   return make_scoped_ptr<SurfaceOzoneEGL>(
       new SurfaceOzoneEgltest(widget, eglplatform_shim_));
 }
 
 bool SurfaceFactoryEgltest::LoadEGLGLES2Bindings(
     AddGLLibraryCallback add_gl_library,
@@ skipping 98 matching lines @@
   virtual GpuPlatformSupport* GetGpuPlatformSupport() OVERRIDE {
     return gpu_platform_support_.get();
   }
   virtual GpuPlatformSupportHost* GetGpuPlatformSupportHost() OVERRIDE {
     return gpu_platform_support_host_.get();
   }
   virtual scoped_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
       const gfx::Rect& bounds) OVERRIDE {
     return make_scoped_ptr<PlatformWindow>(
-        new PlatformWindowCompat(delegate, bounds));
+        new EgltestWindow(delegate, &eglplatform_shim_, bounds));
   }
 
 #if defined(OS_CHROMEOS)
   virtual scoped_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate()
       OVERRIDE {
     return scoped_ptr<NativeDisplayDelegate>(new NativeDisplayDelegateOzone());
   }
   virtual scoped_ptr<TouchscreenDeviceManager>
       CreateTouchscreenDeviceManager() OVERRIDE {
     return scoped_ptr<TouchscreenDeviceManager>(
@@ skipping 35 matching lines @@
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformEgltest() {
   OzonePlatformEgltest* platform = new OzonePlatformEgltest;
   platform->Initialize();
   return platform;
 }
 
 }  // namespace ui