tizen 2.4 release

[framework/web/wrt-plugins-common.git] / src / Commons / EventReceiver.h

diff --git a/src_mobile/Commons/EventReceiver.h b/src/Commons/EventReceiver.h
similarity index 81%
rename from src_mobile/Commons/EventReceiver.h
rename to src/Commons/EventReceiver.h
index 3d7c67b..7a46e36 100644 (file)
--- a/src_mobile/Commons/EventReceiver.h
+++ b/src/Commons/EventReceiver.h
@@ -21,12 +21,14 @@
 #ifndef WRTDEVICEAPIS_COMMONS_EVENT_RECEIVER_H_
 #define WRTDEVICEAPIS_COMMONS_EVENT_RECEIVER_H_
 
+#include <memory>
+#include <mutex>
 #include <assert.h>
 #include <dpl/event/thread_event_dispatcher.h>
-#include <dpl/shared_ptr.h>
 #include <dpl/event/controller.h>
 #include <dpl/type_list.h>
 #include <dpl/event/abstract_event_call.h>
+#include <dpl/log/log.h>
 #include <dpl/log/secure_log.h>
 #include <Commons/ThreadPool.h>
 
@@ -35,11 +37,11 @@ namespace Commons {
 template<class TemplateEvent>
 class SignalEventCall : public DPL::Event::AbstractEventCall
 {
-    DPL::SharedPtr<TemplateEvent> m_event;
+    std::shared_ptr<TemplateEvent> m_event;
 
   public:
 
-    SignalEventCall(const DPL::SharedPtr<TemplateEvent> &event) : m_event(event)
+    SignalEventCall(const std::shared_ptr<TemplateEvent> &event) : m_event(event)
     {}
     virtual void Call()
     {
@@ -51,7 +53,7 @@ class SignalEventCall : public DPL::Event::AbstractEventCall
 template<class TemplateEvent>
 class EventReceiver :
     protected DPL::Event::Controller<
-        typename DPL::TypeListDecl<DPL::SharedPtr<TemplateEvent> >::Type>
+        typename DPL::TypeListDecl<std::shared_ptr<TemplateEvent> >::Type>
 {
     DPL::Event::ThreadEventDispatcher m_threadDispatcher;
 
@@ -61,13 +63,13 @@ class EventReceiver :
     {
         DPL::Thread *thread =
             ThreadPool::getInstance().getThreadRef(threadType);
-        DPL::Event::ControllerEventHandler<DPL::SharedPtr<TemplateEvent> >::
+        DPL::Event::ControllerEventHandler<std::shared_ptr<TemplateEvent> >::
             Touch();
-        DPL::Event::ControllerEventHandler<DPL::SharedPtr<TemplateEvent> >::
+        DPL::Event::ControllerEventHandler<std::shared_ptr<TemplateEvent> >::
             SwitchToThread(thread);
     }
 
-    void signalEventByDispatcher(const DPL::SharedPtr<TemplateEvent> &event)
+    void signalEventByDispatcher(const std::shared_ptr<TemplateEvent> &event)
     {
         _D("called");
         Try {
@@ -86,7 +88,7 @@ class EventReceiver :
 
     virtual ~EventReceiver()
     {
-        DPL::Event::ControllerEventHandler<DPL::SharedPtr<TemplateEvent> >::
+        DPL::Event::ControllerEventHandler<std::shared_ptr<TemplateEvent> >::
             SwitchToThread(NULL);
     }
 };
@@ -98,21 +100,21 @@ class EventRequestReceiver : private EventReceiver<TemplateEvent>
     EventRequestReceiver(ThreadEnum::Enumeration threadType) : EventReceiver<
             TemplateEvent>(threadType)
     {}
-    virtual void OnRequestReceived(const DPL::SharedPtr<TemplateEvent> &event)
-        = 0;
+
+    virtual void OnRequestReceived(const std::shared_ptr<TemplateEvent> &) = 0;
 
     /*
      *
      * @argument delaySeconds - event will be received not sooner than after
      * delay (in seconds)
      */
-    void PostRequest(const DPL::SharedPtr<TemplateEvent> &event,
+    void PostRequest(const std::shared_ptr<TemplateEvent> &event,
                      double delaySeconds = 0.0)
     {
         _D("called");
         {
-            DPL::Mutex::ScopedLock lock(&event->m_stateMutex);
-            assert(TemplateEvent::STATE_INITIAL == event->m_state);
+            std::lock_guard<std::mutex> lock(event->m_stateMutex);
+            Assert(TemplateEvent::STATE_INITIAL == event->m_state);
             event->m_state = TemplateEvent::STATE_REQUEST_SEND;
         }
 
@@ -123,18 +125,18 @@ class EventRequestReceiver : private EventReceiver<TemplateEvent>
         }
 
         if (0.0 == delaySeconds) {
-            DPL::Event::ControllerEventHandler<DPL::SharedPtr<TemplateEvent> >
+            DPL::Event::ControllerEventHandler<std::shared_ptr<TemplateEvent> >
                 ::
                 PostEvent(event);
         } else {
-            DPL::Event::ControllerEventHandler<DPL::SharedPtr<TemplateEvent> >
+            DPL::Event::ControllerEventHandler<std::shared_ptr<TemplateEvent> >
                 ::
                 PostTimedEvent(event, delaySeconds);
         }
 
         switch (event->getHandlingType()) {
         case TemplateEvent::HANDLING_NOT_SET:
-            assert(0);
+            Assert(0);
             break;
         case TemplateEvent::HANDLING_SYNCHRONOUS:
             event->waitForAnswer();
@@ -142,11 +144,11 @@ class EventRequestReceiver : private EventReceiver<TemplateEvent>
         }
     }
 
-    void OnEventReceived(const DPL::SharedPtr<TemplateEvent> &event)
+    void OnEventReceived(const std::shared_ptr<TemplateEvent> &event)
     {
         _D("called");
         {
-            DPL::Mutex::ScopedLock lock(&event->m_stateMutex);
+            std::lock_guard<std::mutex> lock(event->m_stateMutex);
             if (event->m_cancelled) {
                 event->handleCancel();
                 event->m_cancelAllowed = true;
@@ -154,7 +156,7 @@ class EventRequestReceiver : private EventReceiver<TemplateEvent>
                 event->signalFinishedFlag();
                 return;
             } else {
-                assert(
+                Assert(
                     TemplateEvent::STATE_REQUEST_SEND == event->m_state &&
                     "Wrong state!");
             }
@@ -166,7 +168,7 @@ class EventRequestReceiver : private EventReceiver<TemplateEvent>
         //After Controller ends processing it should call it to signal that work
         // is done
         {
-            DPL::Mutex::ScopedLock lock(&event->m_stateMutex);
+            std::lock_guard<std::mutex> lock(event->m_stateMutex);
 
             if (event->m_cancelled) {
                 //if cancel was not handled in OnRequestReceived when we should
@@ -189,7 +191,7 @@ class EventRequestReceiver : private EventReceiver<TemplateEvent>
 
         switch (event->m_handlingType) {
         case TemplateEvent::HANDLING_NOT_SET:
-            assert(0);
+            Assert(0);
             break;
         case TemplateEvent::HANDLING_SYNCHRONOUS:
             //event->Signal();
@@ -211,16 +213,16 @@ class EventRequestReceiver : private EventReceiver<TemplateEvent>
         }
     }
 
-    virtual void ManualAnswer(const DPL::SharedPtr<TemplateEvent> &event)
+    virtual void ManualAnswer(const std::shared_ptr<TemplateEvent> &event)
     {
         _D("called");
-        assert(
+        Assert(
             event->m_handlingType ==
             TemplateEvent::HANDLING_ASYNCHRONOUS_MANUAL_ANSWER ||
             event->m_handlingType ==
             TemplateEvent::HANDLING_SYNCHRONOUS_MANUAL_ANSWER);
         {
-            DPL::Mutex::ScopedLock lock(&event->m_stateMutex);
+            std::lock_guard<std::mutex> lock(event->m_stateMutex);
             if (event->m_cancelled) {
                 //if cancel was not handled in OnRequestReceived when we should
                 //process as if it was not cancelled at all.
@@ -259,25 +261,24 @@ class EventAnswerReceiver : private EventReceiver<TemplateEvent>
             TemplateEvent>(threadType)
     {}
 
-    virtual void OnAnswerReceived(const DPL::SharedPtr<TemplateEvent> &event) =
-        0;
+    virtual void OnAnswerReceived(const std::shared_ptr<TemplateEvent> &) = 0;
 
     //it should be hidden outside, but I can't do it! I can't! :|
-    void PostAnswer(const DPL::SharedPtr<TemplateEvent> &event)
+    void PostAnswer(const std::shared_ptr<TemplateEvent> &event)
     {
-        LogDebug(__FUNCTION__);
+        _D("called");
         event->signalCancelStatusFlag();
-        DPL::Event::ControllerEventHandler<DPL::SharedPtr<TemplateEvent> >::
+        DPL::Event::ControllerEventHandler<std::shared_ptr<TemplateEvent> >::
             PostEvent(
             event);
     }
 
-    void OnEventReceived(const DPL::SharedPtr<TemplateEvent> &event)
+    void OnEventReceived(const std::shared_ptr<TemplateEvent> &event)
     {
         _D("EventAnswerReceiver: answer received");
         //check if it can be processed and set the state
         {
-            DPL::Mutex::ScopedLock lock(&event->m_stateMutex);
+            std::lock_guard<std::mutex> lock(event->m_stateMutex);
 
             //in case someone changed it to synchronous call, we don't process
             // it
@@ -288,7 +289,7 @@ class EventAnswerReceiver : private EventReceiver<TemplateEvent>
                 return;
             }
             //we should get cancelled or answer_send state here
-            assert(
+            Assert(
                 TemplateEvent::STATE_ANSWER_SEND == event->m_state &&
                 "Wrong state!");
 
@@ -303,8 +304,8 @@ class EventAnswerReceiver : private EventReceiver<TemplateEvent>
         OnAnswerReceived(event);
 
         {
-            DPL::Mutex::ScopedLock lock(&event->m_stateMutex);
-            assert(TemplateEvent::STATE_ANSWER_RECEIVED == event->m_state);
+            std::lock_guard<std::mutex> lock(event->m_stateMutex);
+            Assert(TemplateEvent::STATE_ANSWER_RECEIVED == event->m_state);
             event->m_state = TemplateEvent::STATE_ENDED;
             delete event->m_cancelStatusFlag;
             event->m_cancelStatusFlag = NULL;