DSWaylandTizenSurface: implementation Tizen Surface protocol

Change-Id: I94eff8b11a74f6406d00118609c128edf6cde769
Signed-off-by: Junkyeong Kim <jk0430.kim@samsung.com>

diff --git a/src/DSWaylandServer/DSWaylandTizenSurface.cpp b/src/DSWaylandServer/DSWaylandTizenSurface.cpp
index a9df7fc..d81d933 100644 (file)
--- a/src/DSWaylandServer/DSWaylandTizenSurface.cpp
+++ b/src/DSWaylandServer/DSWaylandTizenSurface.cpp
@@ -28,26 +28,56 @@ namespace display_server
 {
 
 /* DSWaylandTizenSurfaceShm */
-DSWaylandTizenSurfaceShmPrivate::DSWaylandTizenSurfaceShmPrivate(DSWaylandTizenSurfaceShm *p_ptr)
+DSWaylandTizenSurfaceShmPrivate::DSWaylandTizenSurfaceShmPrivate(DSWaylandTizenSurfaceShm *p_ptr, DSWaylandCompositor *compositor)
        : DSObjectPrivate(p_ptr),
-         __p_ptr(p_ptr)
+         __p_ptr(p_ptr),
+         __shmFlusher(nullptr)
 {
+       if (!compositor)
+               return;
+
+       tizen_surface_shm::init(compositor->display(), 2);
 }
 
 DSWaylandTizenSurfaceShmPrivate::~DSWaylandTizenSurfaceShmPrivate()
 {
+       if (__shmFlusher != nullptr)
+       {
+               delete __shmFlusher;
+               __shmFlusher = nullptr;
+       }
 }
 
 void DSWaylandTizenSurfaceShmPrivate::tizen_surface_shm_get_flusher(tizen_surface_shm::Resource *resource, uint32_t id, struct ::wl_resource *surface)
 {
+       if (__shmFlusher != nullptr)
+       {
+               if (__shmFlusher->getShmFlusherSurface() == surface)
+               {
+                       DSLOG_ERR("DSWaylandShm", "cannot get shmflusher with same surface.");
+                       return;
+               }
+               else
+               {
+                       DSLOG_INF("DSWaylandShm", "delete previous shmflusher.");
+                       delete __shmFlusher;
+               }
+       }
+
+       __shmFlusher = new DSWaylandTizenSurfaceShmFlusher(resource->client(), id, surface);
 }
 
 void DSWaylandTizenSurfaceShmPrivate::tizen_surface_shm_destroy(tizen_surface_shm::Resource *resource)
 {
+       if (__shmFlusher != nullptr)
+       {
+               delete __shmFlusher;
+               __shmFlusher = nullptr;
+       }
 }
 
-DSWaylandTizenSurfaceShm::DSWaylandTizenSurfaceShm()
-       : DS_INIT_PRIVATE_PTR(DSWaylandTizenSurfaceShm)
+DSWaylandTizenSurfaceShm::DSWaylandTizenSurfaceShm(DSWaylandCompositor *compositor)
+       : _d_ptr(std::make_unique<DSWaylandTizenSurfaceShmPrivate>(this, compositor))
 {
 }
 
@@ -55,23 +85,53 @@ DSWaylandTizenSurfaceShm::~DSWaylandTizenSurfaceShm()
 {
 }
 
+DSWaylandTizenSurfaceShmFlusher *DSWaylandTizenSurfaceShm::getShmFlusher(DSWaylandTizenSurfaceShm *TizenSurfaceShm)
+{
+       DS_GET_PRIV(DSWaylandTizenSurfaceShm);
+
+       return priv->__shmFlusher;
+}
+
+
 /* DSWaylandTizenSurfaceShmFlusher */
-DSWaylandTizenSurfaceShmFlusherPrivate::DSWaylandTizenSurfaceShmFlusherPrivate(DSWaylandTizenSurfaceShmFlusher *p_ptr)
+DSWaylandTizenSurfaceShmFlusherPrivate::DSWaylandTizenSurfaceShmFlusherPrivate(DSWaylandTizenSurfaceShmFlusher *p_ptr, struct ::wl_client *client, uint32_t id, struct ::wl_resource *surface)
        : DSObjectPrivate(p_ptr),
-         __p_ptr(p_ptr)
+         __p_ptr(p_ptr),
+         __surface(nullptr)
 {
+       init(client, id, 2);
+       __surface = surface;
 }
 
 DSWaylandTizenSurfaceShmFlusherPrivate::~DSWaylandTizenSurfaceShmFlusherPrivate()
 {
 }
 
+void DSWaylandTizenSurfaceShmFlusherPrivate::tizen_surface_shm_flusher_bind_resource(Resource *resource)
+{
+}
+
 void DSWaylandTizenSurfaceShmFlusherPrivate::tizen_surface_shm_flusher_destroy(Resource *resource)
 {
 }
 
-DSWaylandTizenSurfaceShmFlusher::DSWaylandTizenSurfaceShmFlusher()
-       : DS_INIT_PRIVATE_PTR(DSWaylandTizenSurfaceShmFlusher)
+void DSWaylandTizenSurfaceShmFlusherPrivate::sendShmFlusherFlush(void)
+{
+       send_flush();
+}
+
+void DSWaylandTizenSurfaceShmFlusherPrivate::sendShmFlusherFreeFlush(void)
+{
+       send_free_flush();
+}
+
+struct ::wl_resource *DSWaylandTizenSurfaceShmFlusherPrivate::getShmFlusherSurface(void)
+{
+       return __surface;
+}
+
+DSWaylandTizenSurfaceShmFlusher::DSWaylandTizenSurfaceShmFlusher(struct ::wl_client *client, uint32_t id, struct ::wl_resource *surface)
+       : _d_ptr(std::make_unique<DSWaylandTizenSurfaceShmFlusherPrivate>(this, client, id, surface))
 {
 }
 
@@ -79,5 +139,29 @@ DSWaylandTizenSurfaceShmFlusher::~DSWaylandTizenSurfaceShmFlusher()
 {
 }
 
-} // namespace display_server
+void DSWaylandTizenSurfaceShmFlusher::sendShmFlusherFlush(void)
+{
+       DS_GET_PRIV(DSWaylandTizenSurfaceShmFlusher);
+
+       DSLOG_INF("DSWaylandShmFlusher", "sendShmFlusherFlush");
+
+       priv->sendShmFlusherFlush();
+}
+
+void DSWaylandTizenSurfaceShmFlusher::sendShmFlusherFreeFlush(void)
+{
+       DS_GET_PRIV(DSWaylandTizenSurfaceShmFlusher);
 
+       DSLOG_INF("DSWaylandShmFlusher", "sendShmFlusherFreeFlush");
+
+       priv->sendShmFlusherFreeFlush();
+}
+
+struct ::wl_resource *DSWaylandTizenSurfaceShmFlusher::getShmFlusherSurface(void)
+{
+       DS_GET_PRIV(DSWaylandTizenSurfaceShmFlusher);
+
+       return priv->getShmFlusherSurface();
+}
+
+} // namespace display_server

diff --git a/src/DSWaylandServer/DSWaylandTizenSurface.h b/src/DSWaylandServer/DSWaylandTizenSurface.h
index b36fa00..b46068c 100644 (file)
--- a/src/DSWaylandServer/DSWaylandTizenSurface.h
+++ b/src/DSWaylandServer/DSWaylandTizenSurface.h
@@ -26,6 +26,8 @@
 
 #include <DSObject.h>
 #include <DSCore.h>
+#include <DSWaylandCompositor.h>
+#include <wayland-server-core.h>
 
 namespace display_server
 {
@@ -33,25 +35,30 @@ namespace display_server
 class DSWaylandTizenSurfaceShmPrivate;
 class DSWaylandTizenSurfaceShmFlusherPrivate;
 
-class DS_DECL_EXPORT DSWaylandTizenSurfaceShm : public DSObject
+class DS_DECL_EXPORT DSWaylandTizenSurfaceShmFlusher : public DSObject
 {
-DS_PIMPL_USE_PRIVATE(DSWaylandTizenSurfaceShm);
+DS_PIMPL_USE_PRIVATE(DSWaylandTizenSurfaceShmFlusher);
 
 public:
-       DSWaylandTizenSurfaceShm();
-       virtual ~DSWaylandTizenSurfaceShm();
+       DSWaylandTizenSurfaceShmFlusher(struct ::wl_client *client, uint32_t id, struct ::wl_resource *surface);
+       virtual ~DSWaylandTizenSurfaceShmFlusher();
+
+       void sendShmFlusherFlush(void);
+       void sendShmFlusherFreeFlush(void);
+       struct ::wl_resource *getShmFlusherSurface(void);
 };
 
-class DS_DECL_EXPORT DSWaylandTizenSurfaceShmFlusher : public DSObject
+class DS_DECL_EXPORT DSWaylandTizenSurfaceShm : public DSObject
 {
-DS_PIMPL_USE_PRIVATE(DSWaylandTizenSurfaceShmFlusher);
+DS_PIMPL_USE_PRIVATE(DSWaylandTizenSurfaceShm);
 
 public:
-       DSWaylandTizenSurfaceShmFlusher();
-       virtual ~DSWaylandTizenSurfaceShmFlusher();
+       DSWaylandTizenSurfaceShm(DSWaylandCompositor *compositor);
+       virtual ~DSWaylandTizenSurfaceShm();
+
+       DSWaylandTizenSurfaceShmFlusher *getShmFlusher(DSWaylandTizenSurfaceShm *TizenSurfaceShm);
 };
 
 }
 
 #endif
-

diff --git a/src/DSWaylandServer/DSWaylandTizenSurfacePrivate.h b/src/DSWaylandServer/DSWaylandTizenSurfacePrivate.h
index 805f0f2..90a184e 100644 (file)
--- a/src/DSWaylandServer/DSWaylandTizenSurfacePrivate.h
+++ b/src/DSWaylandServer/DSWaylandTizenSurfacePrivate.h
@@ -30,38 +30,42 @@
 namespace display_server
 {
 
-class DS_DECL_EXPORT DSWaylandTizenSurfaceShmPrivate : public DSObjectPrivate, public DSWaylandServer::tizen_surface_shm
+class DS_DECL_EXPORT DSWaylandTizenSurfaceShmFlusherPrivate : public DSObjectPrivate, public DSWaylandServer::tizen_surface_shm_flusher
 {
-DS_PIMPL_USE_PUBLIC(DSWaylandTizenSurfaceShm);
+DS_PIMPL_USE_PUBLIC(DSWaylandTizenSurfaceShmFlusher);
 
 public:
-       DSWaylandTizenSurfaceShmPrivate() = delete;
-       DSWaylandTizenSurfaceShmPrivate(DSWaylandTizenSurfaceShm *p_ptr);
-       ~DSWaylandTizenSurfaceShmPrivate() override;
+       DSWaylandTizenSurfaceShmFlusherPrivate() = delete;
+       DSWaylandTizenSurfaceShmFlusherPrivate(DSWaylandTizenSurfaceShmFlusher *p_ptr, struct ::wl_client *client, uint32_t id, struct ::wl_resource *surface);
+       ~DSWaylandTizenSurfaceShmFlusherPrivate() override;
+
+       void sendShmFlusherFlush(void);
+       void sendShmFlusherFreeFlush(void);
 
+       struct ::wl_resource *getShmFlusherSurface(void);
 protected:
-       void tizen_surface_shm_get_flusher(Resource *resource, uint32_t id, struct ::wl_resource *surface) override;
-       void tizen_surface_shm_destroy(Resource *resource) override;
+       void tizen_surface_shm_flusher_bind_resource(Resource *resource) override;
+       void tizen_surface_shm_flusher_destroy(Resource *resource) override;
 private:
-       /* data */
+       struct ::wl_resource *__surface;
 };
 
-class DS_DECL_EXPORT DSWaylandTizenSurfaceShmFlusherPrivate : public DSObjectPrivate, public DSWaylandServer::tizen_surface_shm_flusher
+class DS_DECL_EXPORT DSWaylandTizenSurfaceShmPrivate : public DSObjectPrivate, public DSWaylandServer::tizen_surface_shm
 {
-DS_PIMPL_USE_PUBLIC(DSWaylandTizenSurfaceShmFlusher);
+DS_PIMPL_USE_PUBLIC(DSWaylandTizenSurfaceShm);
 
 public:
-       DSWaylandTizenSurfaceShmFlusherPrivate() = delete;
-       DSWaylandTizenSurfaceShmFlusherPrivate(DSWaylandTizenSurfaceShmFlusher *p_ptr);
-       ~DSWaylandTizenSurfaceShmFlusherPrivate() override;
+       DSWaylandTizenSurfaceShmPrivate() = delete;
+       DSWaylandTizenSurfaceShmPrivate(DSWaylandTizenSurfaceShm *p_ptr, DSWaylandCompositor *compositor);
+       ~DSWaylandTizenSurfaceShmPrivate() override;
 
 protected:
-       void tizen_surface_shm_flusher_destroy(Resource *resource) override;
+       void tizen_surface_shm_get_flusher(Resource *resource, uint32_t id, struct ::wl_resource *surface) override;
+       void tizen_surface_shm_destroy(Resource *resource) override;
 private:
-       /* data */
+       DSWaylandTizenSurfaceShmFlusher *__shmFlusher;
 };
 
 }
 
 #endif
-

diff --git a/tests/DSWaylandTizenSurface-test.cpp b/tests/DSWaylandTizenSurface-test.cpp
index bb988a6..68cf4a3 100644 (file)
--- a/tests/DSWaylandTizenSurface-test.cpp
+++ b/tests/DSWaylandTizenSurface-test.cpp
@@ -37,19 +37,11 @@ public:
 
 TEST_F(DSWaylandTizenSurfaceTest, NewDSWaylandTizenSurfaceShm)
 {
-       DSWaylandTizenSurfaceShm *shm = new DSWaylandTizenSurfaceShm;
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandTizenSurfaceShm *shm = new DSWaylandTizenSurfaceShm(comp);
        EXPECT_TRUE(shm != nullptr);
 
        if (shm)
                delete shm;
+       DSWaylandCompositor::releaseInstance();
 }
-
-TEST_F(DSWaylandTizenSurfaceTest, NewDSWaylandTizenSurfaceShmFlusher)
-{
-       DSWaylandTizenSurfaceShmFlusher *shmFlusher = new DSWaylandTizenSurfaceShmFlusher;
-       EXPECT_TRUE(shmFlusher != nullptr);
-
-       if (shmFlusher)
-               delete shmFlusher;
-}
-