Merge lp:~dandrader/frame/smarter_backend into lp:frame

[Daniel d'Andrada]

Add some helper functions to the backend API and lazy copy for touches.

The new functions are:
 - frame_backend_frame_create_next
 - frame_backend_frame_get_touch_by_id

With those functions, backend implementors can more easily write efficient and error-free implementations.

[Chase Douglas (chasedouglas)]

* The Window class no longer needs to subclass std::enable_shared_from_this<Window>.

* Any functions that may fail need to return a UFStatus and provide the return result through a referenced parameter. All of the new functions here should do this. I forgot about this when I approved the previous merge proposal as well. We should go back and fix these up.

* There's a stray newline at the end of UFFrame::GetSharedTouchById.

Everything else looks good :). This should really help backend implementations get things right the first time.

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> * Any functions that may fail need to return a UFStatus and provide the return
> result through a referenced parameter. All of the new functions here should do
> this. I forgot about this when I approved the previous merge proposal as well.
> We should go back and fix these up.

Isn't that extra status variable redundant in those cases? What's the benefit?

[Chase Douglas (chasedouglas)]

On 08/30/2012 11:01 AM, Daniel d'Andrada wrote:
>> * Any functions that may fail need to return a UFStatus and provide the return
>> result through a referenced parameter. All of the new functions here should do
>> this. I forgot about this when I approved the previous merge proposal as well.
>> We should go back and fix these up.
>
> Isn't that extra status variable redundant in those cases? What's the benefit?

Let's take a function like:

UFBackendTouch frame_backend_frame_get_touch_by_id(
     UFBackendFrame frame, UFTouchId id)

Without knowing exactly how this is implemented, there are two possible
recoverable error conditions:

1. The touch ID is invalid (UFStatusErrorInvalidTouch)
2. The allocation and initialization of UFBackendTouch could fail
(UFStatusErrorResources or UFStatusErrorGeneric)

The current implementation doesn't actually catch allocation and
initialization exceptions, but it could if we found that to be a problem.

The client could use this information to determine how to proceed. It's
almost impossible to recover from allocation errors, so the client could
abort. However, if the touch ID is invalid, it could stop processing
gestures for that frame and continue on. At the very least, it could log
a more meaningful error message, which has been helpful in debugging
issues in the past.

The other main reason is that it maintains the cohesiveness of the API.
The entire grail and frame API behaves like this. It makes sense to
continue using the same mechanism.

I'm not a huge fan of the API, tbh. I much prefer an exception based
approach. However, this is C, and there's only so much you can do with a
C API. There is one benefit to the API, however, and it becomes when you
actively check the return value.

UFBackendTouch be_touch;
assert(frame_backend_frame_get_touch_by_id(frame, id, &be_touch) ==
        UFStatusSuccess);

As opposed to:

UFBackendTouch be_touch;
assert((be_touch = frame_backend_frame_get_touch_by_id(frame, id)) !=
        nullptr);

My personal opinion is that the second approach is messy because you are
both assigning a value and using C's () operator to check the assigned
value is correct, all in one statement of code. You could split it up,
but then you're using more lines of code and it isn't any more
comprehensible versus the original approach, imo.

[Daniel d'Andrada (dandrader)]

> On 08/30/2012 11:01 AM, Daniel d'Andrada wrote:
> >> * Any functions that may fail need to return a UFStatus and provide the
> return
> >> result through a referenced parameter. All of the new functions here should
> do
> >> this. I forgot about this when I approved the previous merge proposal as
> well.
> >> We should go back and fix these up.
> >
> > Isn't that extra status variable redundant in those cases? What's the
> benefit?
>
> Let's take a function like:
>
> UFBackendTouch frame_backend_frame_get_touch_by_id(
> UFBackendFrame frame, UFTouchId id)
>
> Without knowing exactly how this is implemented, there are two possible
> recoverable error conditions:
>
> 1. The touch ID is invalid (UFStatusErrorInvalidTouch)
> 2. The allocation and initialization of UFBackendTouch could fail
> (UFStatusErrorResources or UFStatusErrorGeneric)
>
> The current implementation doesn't actually catch allocation and
> initialization exceptions, but it could if we found that to be a problem.
>
> The client could use this information to determine how to proceed. It's
> almost impossible to recover from allocation errors, so the client could
> abort. However, if the touch ID is invalid, it could stop processing
> gestures for that frame and continue on. At the very least, it could log
> a more meaningful error message, which has been helpful in debugging
> issues in the past.

You're right.
Thanks for the explanation!

[Daniel d'Andrada (dandrader)]

Updated

[lp:~dandrader/frame/smarter_backend]

96. By Daniel d'Andrada on 2012-08-31

Plug a memory leak in test Backend::FrameCreateNext

[Chase Douglas (chasedouglas)]

* In frame_backend_frame_borrow_touch_by_id(), if it fails because the touch ID doesn't exist, the touch pointer is reset to NULL. This should be nullptr instead of NULL, but I would argue it shouldn't be reset at all. One technique often employed by APIs is that either a function succeeds, or it fails and does not modify any state. It can be hard or practically impossible to do this in some circumstances, but here it is as simple as not resetting the touch pointer value. I can't give you any specific scenario under which this particular change would be helpful, but I prefer the API to behave like this as much as possible.

* In frame_backend_frame_give_touch(), I think *touch should be set to nullptr instead of 0. Or maybe I'm not realizing something that makes that not work?

Otherwise, I'm ok with everything. It's not exactly how I would do it, but I don't know of a 100% best alternative either.

review: Approve

[lp:~dandrader/frame/smarter_backend]

97. By Daniel d'Andrada on 2012-08-31

Minor tweaks

98. By Daniel d'Andrada on 2012-08-31

A bit more tests

=== modified file 'include/oif/frame.h'
--- include/oif/frame.h	2012-07-24 21:36:05 +0000
+++ include/oif/frame.h	2012-08-31 19:29:21 +0000
@@ -89,6 +89,7 @@
   UFStatusErrorInvalidType, /**< The variable type passed as a void pointer into
                                  a property getter is invalid for the property
                              */
+  UFStatusErrorTouchIdExists, /**< A touch with the same ID already exists */
 } UFStatus;
 
 /** Properties of a device */

=== modified file 'include/oif/frame_backend.h'
--- include/oif/frame_backend.h	2012-08-28 19:54:18 +0000
+++ include/oif/frame_backend.h	2012-08-31 19:29:21 +0000
@@ -132,18 +132,53 @@
  ********************************************************************/
 
 /**
- * Creates a new UFFrame and returns its backend handle.
+ * Creates a new, empty, UFFrame and returns its backend handle.
+ *
+ * Usually you will use this method only for the very first frame. For all
+ * subsequent ones it will be safer and more convinent to use
+ * frame_backend_frame_create_next().
  */
 FRAME_PUBLIC
 UFBackendFrame frame_backend_frame_new();
 
 /**
+ * Creates a new UFFrame that is a continuation of the given one.
+ *
+ * Touches that had a "begin" state on the given frame will be hard-copied and
+ * have an "update" state on the new frame.
+ *
+ * Touches that had an "update" state will be lazily copied to the new frame.
+ *
+ * Touches that had a "end" state on the given frame won't be present
+ * on the new frame.
+ */
+FRAME_PUBLIC
+UFBackendFrame frame_backend_frame_create_next(UFBackendFrame frame);
+
+/**
  * Returns a UFFrame instance given its backend handle.
  */
 FRAME_PUBLIC
 UFFrame frame_backend_frame_get_frame(UFBackendFrame frame);
 
 /**
+ * Gets a UFBackendTouch for the UFTouch that has the given id.
+ *
+ * The underlying UFTouch is moved from the given frame to the returned UFBackendTouch.
+ * Once done modifying the touch you're expected to return it to the frame via
+ * frame_backend_frame_give_touch().
+ *
+ * If the underlying UFTouch is a lazy copy (likely from a touch in the previous frame), a hard copy
+ * will be made upon the first change made to it.
+ *
+ * Possible errors: UFStatusErrorInvalidTouch
+ */
+FRAME_PUBLIC
+UFStatus frame_backend_frame_borrow_touch_by_id(UFBackendFrame frame,
+                                                UFTouchId id,
+                                                UFBackendTouch *touch);
+
+/**
  * Sets the "Device" property of the given frame
  */
 FRAME_PUBLIC
@@ -164,10 +199,15 @@
 void frame_backend_frame_set_active_touches(UFBackendFrame frame, unsigned int active_touches);
 
 /**
- * Adds a UFTouch to the given frame.
+ * Gives a UFTouch to the specified frame.
+ *
+ * Gives the underlying UFTouch to the specified frame. The UFBackendTouch
+ * is deleted and no longer valid after this call.
+ *
+ * Possible errors: UFStatusErrorTouchIdExists
  */
 FRAME_PUBLIC
-void frame_backend_frame_add_touch(UFBackendFrame frame, UFBackendTouch touch);
+UFStatus frame_backend_frame_give_touch(UFBackendFrame frame, UFBackendTouch *touch);
 
 /**
  * Deletes the backend handle of a UFFrame,
@@ -182,6 +222,10 @@
 
 /**
  * Creates a new UFTouch and returns its backend handle.
+ *
+ * Its state will be set to "Begin".
+ *
+ * After filled out, it should be given to a frame via frame_backend_frame_give_touch()
  */
 FRAME_PUBLIC
 UFBackendTouch frame_backend_touch_new();
@@ -199,10 +243,10 @@
 void frame_backend_touch_set_id(UFBackendTouch touch, UFTouchId id);
 
 /**
- * Sets the "State" property of the given touch
+ * Sets the "State" property of the given touch to "End"
  */
 FRAME_PUBLIC
-void frame_backend_touch_set_state(UFBackendTouch touch, UFTouchState state);
+void frame_backend_touch_set_ended(UFBackendTouch touch);
 
 /**
  * Sets the "WindowX" and "WindowY" properties of the given touch
@@ -240,13 +284,6 @@
 FRAME_PUBLIC
 void frame_backend_touch_set_value(UFBackendTouch touch, UFAxisType type, float value);
 
-/**
- * Deletes the backend handle of a UFTouch,
- * decreasing its reference count by one.
- */
-FRAME_PUBLIC
-void frame_backend_touch_delete(UFBackendTouch touch);
-
 #ifdef __cplusplus
 }
 #endif

=== modified file 'src/frame.cpp'
--- src/frame.cpp	2012-08-29 18:54:16 +0000
+++ src/frame.cpp	2012-08-31 19:29:21 +0000
@@ -25,16 +25,14 @@
 
 #include "device.h"
 #include "touch.h"
-#include "window.h"
 
 #include <oif/frame_backend.h>
 
 namespace oif {
 namespace frame {
 
-UFFrame::UFFrame(const SharedWindow& window, const SharedUFFrame& prev)
+UFFrame::UFFrame(const SharedUFFrame& prev)
     : prev_(prev),
-      window_(window),
       touches_array_(),
       touches_map_() {
   for (const SharedUFTouch& prev_touch : prev_->touches_array_) {
@@ -96,10 +94,28 @@
 
 } // namespace
 
-void UFFrame::AddTouch(const SharedUFTouch& touch)
-{
-  touches_map_[touch->id()] = touches_array_.size();
-  touches_array_.push_back(touch);
+UFStatus UFFrame::GiveTouch(SharedUFTouch& touch) {
+  auto map_it = touches_map_.find(touch->id());
+  if (map_it != touches_map_.end()) {
+    /* A loan is being returned */
+
+    SharedUFTouch &our_touch = touches_array_[map_it->second];
+
+    /* we shouldn't be referencing to any UFTouch here.
+       If we are, it's a programming error by the API user. */
+    if (our_touch.get() != NULL) {
+      return UFStatusErrorTouchIdExists;
+    }
+
+    /* take back our UFtouch */
+    our_touch.swap(touch);
+  } else {
+    touches_map_[touch->id()] = touches_array_.size();
+    touches_array_.push_back(touch);
+    touch.reset();
+  }
+
+  return UFStatusSuccess;
 }
 
 void UFFrame::UpdateTouch(const SharedUFTouch& touch) {
@@ -111,7 +127,8 @@
         CopyStartTime(touches_array_[map_it->second], touch);
         touches_array_[map_it->second] = touch;
       } else {
-        AddTouch(touch);
+        touches_map_[touch->id()] = touches_array_.size();
+        touches_array_.push_back(touch);
       }
       break;
 
@@ -171,6 +188,14 @@
   return UFStatusSuccess;
 }
 
+SharedUFTouch* UFFrame::GetSharedTouchById(UFTouchId touch_id) {
+  auto it = touches_map_.find(touch_id);
+  if (it == touches_map_.end())
+    return nullptr;
+  else
+    return &(touches_array_[it->second]);
+}
+
 UFStatus UFFrame::GetTouchById(UFTouchId touch_id, ::UFTouch* touch) const {
   auto it = touches_map_.find(touch_id);
   if (it == touches_map_.end())
@@ -316,11 +341,32 @@
   return new UFBackendFrame_(new oif::frame::UFFrame);
 }
 
+UFBackendFrame frame_backend_frame_create_next(UFBackendFrame frame)
+{
+  return new UFBackendFrame_(new oif::frame::UFFrame(frame->shared_ptr));
+}
+
 UFFrame frame_backend_frame_get_frame(UFBackendFrame frame)
 {
   return frame->shared_ptr.get();
 }
 
+UFStatus frame_backend_frame_borrow_touch_by_id(UFBackendFrame frame,
+                                                UFTouchId id,
+                                                UFBackendTouch *touch)
+{
+  oif::frame::UFFrame* ufframe =
+    static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get());
+
+  oif::frame::SharedUFTouch *shared_touch = ufframe->GetSharedTouchById(id);
+  if (shared_touch) {
+    *touch = new UFBackendTouch_(*shared_touch);
+    return UFStatusSuccess;
+  } else {
+    return UFStatusErrorInvalidTouch;
+  }
+}
+
 void frame_backend_frame_set_device(UFBackendFrame frame, UFBackendDevice device)
 {
   static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get())->
@@ -342,10 +388,23 @@
                    new oif::frame::Value(active_touches));
 }
 
-void frame_backend_frame_add_touch(UFBackendFrame frame, UFBackendTouch touch)
+UFStatus frame_backend_frame_give_touch(UFBackendFrame frame, UFBackendTouch *touch)
 {
-  static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get())->
-    AddTouch(touch->shared_ptr);
+  UFStatus status;
+
+  /* the touch backend must be carrying a UFtouch */
+  assert((*touch)->shared_ptr);
+
+  status = static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get())->
+    GiveTouch((*touch)->shared_ptr);
+
+  /* frame must have taken the touch */
+  assert(!(*touch)->shared_ptr);
+
+  delete (*touch);
+  *touch = nullptr;
+
+  return status;
 }
 
 void frame_backend_frame_delete(UFBackendFrame frame)

=== modified file 'src/frame.h'
--- src/frame.h	2012-08-28 19:51:37 +0000
+++ src/frame.h	2012-08-31 19:29:21 +0000
@@ -45,12 +45,12 @@
 
 class UFFrame : public UFFrame_, public Property<UFFrameProperty> {
  public:
-  UFFrame() : prev_(), window_(), touches_array_(), touches_map_() {}
-  UFFrame(const SharedWindow& window, const SharedUFFrame& prev);
+  UFFrame() : prev_(), touches_array_(), touches_map_() {}
+  UFFrame(const SharedUFFrame& prev);
 
   UFTouch* CopyTouch(UFTouchId touchid, UFTouchState new_state) const;
   bool IsTouchOwned(UFTouchId touchid);
-  void AddTouch(const SharedUFTouch& touch);
+  UFStatus GiveTouch(SharedUFTouch& touch);
   void UpdateTouch(const SharedUFTouch& touch);
   bool IsEnded() const;
   unsigned int GetNumTouches() const { return touches_array_.size(); }
@@ -59,6 +59,7 @@
   UFStatus GetPreviousTouchProperty(const UFTouch* touch,
                                     UFTouchProperty property, void* value) const;
   UFStatus GetTouchByIndex(unsigned int index, ::UFTouch* touch) const;
+  SharedUFTouch* GetSharedTouchById(UFTouchId touch_id);
   UFStatus GetTouchById(UFTouchId touch_id, ::UFTouch* touch) const;
   void ReleasePreviousFrame();
 
@@ -67,7 +68,6 @@
 
  private:
   SharedUFFrame prev_;
-  SharedWindow window_;
   std::vector<SharedUFTouch> touches_array_;
   std::map<UFTouchId, unsigned int> touches_map_;
 };

=== modified file 'src/libframe.ver'
--- src/libframe.ver	2012-08-28 19:51:37 +0000
+++ src/libframe.ver	2012-08-31 19:29:21 +0000
@@ -77,23 +77,24 @@
     frame_backend_device_set_window_resolution;
     frame_backend_device_add_axis;
     frame_backend_frame_new;
+    frame_backend_frame_create_next;
     frame_backend_frame_get_frame;
+    frame_backend_frame_borrow_touch_by_id;
     frame_backend_frame_set_device;
     frame_backend_frame_set_window_id;
     frame_backend_frame_set_active_touches;
-    frame_backend_frame_add_touch;
+    frame_backend_frame_give_touch;
     frame_backend_frame_delete;
     frame_backend_touch_new;
     frame_backend_touch_get_touch;
     frame_backend_touch_set_id;
-    frame_backend_touch_set_state;
+    frame_backend_touch_set_ended;
     frame_backend_touch_set_window_pos;
     frame_backend_touch_set_time;
     frame_backend_touch_set_start_time;
     frame_backend_touch_set_owned;
     frame_backend_touch_set_pending_end;
     frame_backend_touch_set_value;
-    frame_backend_touch_delete;
 
   local:
     *;

=== modified file 'src/touch.cpp'
--- src/touch.cpp	2012-08-28 18:20:51 +0000
+++ src/touch.cpp	2012-08-31 19:29:21 +0000
@@ -26,9 +26,32 @@
 
 #include <oif/frame_backend.h>
 
+oif::frame::UFTouch* UFBackendTouch_::GetModifiableTouch() {
+  if (shared_ptr.unique()) {
+    return static_cast<oif::frame::UFTouch*>(shared_ptr.get());
+  } else {
+    /* Make a hard-copy. We don't want other holders of that UFTouch (like frames
+       from previous but still existing events) to get the changes about to be
+       made through this UFBackendTouch. */
+    oif::frame::UFTouch *old_touch =
+      static_cast<oif::frame::UFTouch*>(shared_ptr.get());
+    oif::frame::UFTouch *new_touch = new oif::frame::UFTouch(*old_touch);
+    shared_ptr.reset(new_touch);
+    return new_touch;
+  }
+}
+
 namespace oif {
 namespace frame {
 
+UFTouch::UFTouch()
+  : state_(UFTouchStateBegin) {
+  const Value* value;
+
+  value = new Value(state_);
+  InsertProperty(UFTouchPropertyState, value);
+}
+
 UFTouch::UFTouch(UFTouchState state, UFTouchId id, float x, float y,
                  uint64_t time)
     : id_(id),
@@ -219,70 +242,63 @@
 
 void frame_backend_touch_set_id(UFBackendTouch touch_backend, UFTouchId id)
 {
-  oif::frame::UFTouch *touch =
-    static_cast<oif::frame::UFTouch*>(touch_backend->shared_ptr.get());
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
 
   touch->InsertProperty(UFTouchPropertyId, new oif::frame::Value(id));
   touch->SetId(id);
 }
 
-void frame_backend_touch_set_state(UFBackendTouch touch_backend, UFTouchState state)
-{
-  oif::frame::UFTouch *touch =
-    static_cast<oif::frame::UFTouch*>(touch_backend->shared_ptr.get());
-
-  touch->InsertProperty(UFTouchPropertyState, new oif::frame::Value(state));
-  touch->SetState(state);
-}
-
-void frame_backend_touch_set_window_pos(UFBackendTouch touch, float x, float y)
-{
-  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
-    InsertProperty(UFTouchPropertyWindowX,
-                   new oif::frame::Value(x));
-
-  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
-    InsertProperty(UFTouchPropertyWindowY,
-                   new oif::frame::Value(y));
-}
-
-void frame_backend_touch_set_time(UFBackendTouch touch, uint64_t time)
-{
-  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
-    InsertProperty(UFTouchPropertyTime,
-                   new oif::frame::Value(time));
-}
-
-void frame_backend_touch_set_start_time(UFBackendTouch touch, uint64_t start_time)
-{
-  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
-    InsertProperty(UFTouchPropertyStartTime,
-                   new oif::frame::Value(start_time));
-}
-
-void frame_backend_touch_set_owned(UFBackendTouch touch, int owned)
-{
-  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
-    InsertProperty(UFTouchPropertyOwned,
-                   new oif::frame::Value(owned));
-}
-
-void frame_backend_touch_set_pending_end(UFBackendTouch touch, int pending_end)
-{
-  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
-    InsertProperty(UFTouchPropertyPendingEnd,
-                   new oif::frame::Value(pending_end));
-}
-
-void frame_backend_touch_set_value(UFBackendTouch touch, UFAxisType type, float value)
-{
-  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
-    SetValue(type, value);
-}
-
-void frame_backend_touch_delete(UFBackendTouch touch)
-{
-  delete touch;
+void frame_backend_touch_set_ended(UFBackendTouch touch_backend)
+{
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
+
+  touch->InsertProperty(UFTouchPropertyState, new oif::frame::Value(UFTouchStateEnd));
+  touch->SetState(UFTouchStateEnd);
+}
+
+void frame_backend_touch_set_window_pos(UFBackendTouch touch_backend, float x, float y)
+{
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
+
+  touch->InsertProperty(UFTouchPropertyWindowX, new oif::frame::Value(x));
+  touch->InsertProperty(UFTouchPropertyWindowY, new oif::frame::Value(y));
+}
+
+void frame_backend_touch_set_time(UFBackendTouch touch_backend, uint64_t time)
+{
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
+
+  touch->InsertProperty(UFTouchPropertyTime, new oif::frame::Value(time));
+}
+
+void frame_backend_touch_set_start_time(UFBackendTouch touch_backend,
+                                        uint64_t start_time)
+{
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
+
+  touch->InsertProperty(UFTouchPropertyStartTime, new oif::frame::Value(start_time));
+}
+
+void frame_backend_touch_set_owned(UFBackendTouch touch_backend, int owned)
+{
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
+
+  touch->InsertProperty(UFTouchPropertyOwned, new oif::frame::Value(owned));
+}
+
+void frame_backend_touch_set_pending_end(UFBackendTouch touch_backend, int pending_end)
+{
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
+
+  touch->InsertProperty(UFTouchPropertyPendingEnd, new oif::frame::Value(pending_end));
+}
+
+void frame_backend_touch_set_value(UFBackendTouch touch_backend,
+                                   UFAxisType type, float value)
+{
+  oif::frame::UFTouch *touch = touch_backend->GetModifiableTouch();
+
+  touch->SetValue(type, value);
 }
 
 } // extern "C"

=== modified file 'src/touch.h'
--- src/touch.h	2012-08-28 18:20:51 +0000
+++ src/touch.h	2012-08-31 19:29:21 +0000
@@ -38,6 +38,12 @@
   UFBackendTouch_(oif::frame::UFTouch* touch)
     : shared_ptr(touch) {}
 
+  UFBackendTouch_(oif::frame::SharedUFTouch &shared_touch) {
+    shared_ptr.swap(shared_touch);
+  }
+
+  oif::frame::UFTouch* GetModifiableTouch();
+
   oif::frame::SharedUFTouch shared_ptr;
 };
 
@@ -46,7 +52,7 @@
 
 class UFTouch : public UFTouch_, public Property<UFTouchProperty> {
  public:
-  UFTouch() {}
+  UFTouch();
   UFTouch(UFTouchState state, UFTouchId id, float x, float y,
            uint64_t time);
   UFTouch(const UFTouch& touch, UFTouchState new_state);
@@ -60,7 +66,6 @@
   void SetValue(UFAxisType type, float value);
   UFStatus GetValue(UFAxisType type, float* value) const;
 
-  UFTouch(const UFTouch&) = delete;
   UFTouch& operator=(const UFTouch&) = delete;
 
  private:

=== modified file 'src/window.h'
--- src/window.h	2012-06-21 19:41:40 +0000
+++ src/window.h	2012-08-31 19:29:21 +0000
@@ -31,7 +31,7 @@
 namespace oif{
 namespace frame {
 
-class Window : public std::enable_shared_from_this<Window> {
+class Window {
  public:
   Window();
   virtual ~Window() {};

=== modified file 'src/x11/window_x11.cpp'
--- src/x11/window_x11.cpp	2012-07-24 20:47:15 +0000
+++ src/x11/window_x11.cpp	2012-08-31 19:29:21 +0000
@@ -76,7 +76,7 @@
       return false;
   }
 
-  *frame = SharedUFFrame(new UFFrame(shared_from_this(), current_frame_));
+  *frame = SharedUFFrame(new UFFrame(current_frame_));
 
   const Value* value = new Value(frame_x11_create_window_id(window_));
   (*frame)->InsertProperty(UFFramePropertyWindowId, value);
@@ -145,7 +145,7 @@
 
 bool WindowX11::HandleOwnershipEvent(const XITouchOwnershipEvent* event,
                                      SharedUFFrame* frame) {
-  *frame = SharedUFFrame(new UFFrame(shared_from_this(), current_frame_));
+  *frame = SharedUFFrame(new UFFrame(current_frame_));
 
   const Value* value = new Value(frame_x11_create_window_id(window_));
   (*frame)->InsertProperty(UFFramePropertyWindowId, value);

=== modified file 'test/regular/backend.cpp'
--- test/regular/backend.cpp	2012-08-28 19:51:37 +0000
+++ test/regular/backend.cpp	2012-08-31 19:29:21 +0000
@@ -11,11 +11,13 @@
   UFTouch touch = frame_backend_touch_get_touch(touch_backend);
   ASSERT_TRUE(touch != nullptr);
 
+  ASSERT_EQ(UFTouchStateBegin, frame_touch_get_state(touch));
+
   frame_backend_touch_set_id(touch_backend, 123);
   ASSERT_EQ(123, frame_touch_get_id(touch));
 
-  frame_backend_touch_set_state(touch_backend, UFTouchStateUpdate);
-  ASSERT_EQ(UFTouchStateUpdate, frame_touch_get_state(touch));
+  frame_backend_touch_set_ended(touch_backend);
+  ASSERT_EQ(UFTouchStateEnd, frame_touch_get_state(touch));
 
   frame_backend_touch_set_window_pos(touch_backend, 1.2f, 3.4f);
   ASSERT_EQ(1.2f, frame_touch_get_window_x(touch));
@@ -45,7 +47,10 @@
   ASSERT_EQ(UFStatusSuccess, status);
   ASSERT_EQ(987.6f, touch_major);
 
-  frame_backend_touch_delete(touch_backend);
+  /* clean up */
+  UFBackendFrame frame = frame_backend_frame_new();
+  frame_backend_frame_give_touch(frame, &touch_backend);
+  frame_backend_frame_delete(frame);
 }
 
 TEST(Backend, Device)
@@ -152,7 +157,9 @@
   status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
   ASSERT_EQ(UFStatusSuccess, status);
   ASSERT_EQ(0, active_touches);
-  frame_backend_frame_add_touch(frame_backend, touch_backend);
+  status = frame_backend_frame_give_touch(frame_backend, &touch_backend);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(nullptr, touch_backend);
   ASSERT_EQ(1, frame_frame_get_num_touches(frame));
   status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
   ASSERT_EQ(UFStatusSuccess, status);
@@ -168,7 +175,83 @@
 
   frame_backend_frame_delete(frame_backend);
   frame_backend_device_delete(device_backend);
-  frame_backend_touch_delete(touch_backend);
+}
+
+TEST(Backend, FrameBorrowInexistentTouch)
+{
+  UFStatus status;
+
+  UFBackendFrame frame_backend = frame_backend_frame_new();
+
+  UFBackendTouch touch_backend;
+  status = frame_backend_frame_borrow_touch_by_id(frame_backend, 123, &touch_backend);
+  ASSERT_EQ(UFStatusErrorInvalidTouch, status);
+
+  /* clean up */
+  frame_backend_frame_delete(frame_backend);
+}
+
+TEST(Backend, FrameCreateNext)
+{
+  UFStatus status;
+
+  /* frame 1  */
+  UFBackendTouch touch_backend = frame_backend_touch_new();
+  frame_backend_touch_set_id(touch_backend, 1);
+  UFTouch frame1_touch = frame_backend_touch_get_touch(touch_backend);
+
+  UFBackendFrame frame1_backend = frame_backend_frame_new();
+  status = frame_backend_frame_give_touch(frame1_backend, &touch_backend);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  /* frame 2 */
+  UFBackendFrame frame2_backend = frame_backend_frame_create_next(frame1_backend);
+  UFFrame frame2 = frame_backend_frame_get_frame(frame2_backend);
+
+  UFTouch frame2_touch;
+  status = frame_frame_get_touch_by_id(frame2, 1, &frame2_touch);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  /* frame 3 */
+  UFBackendFrame frame3_backend = frame_backend_frame_create_next(frame2_backend);
+  UFFrame frame3 = frame_backend_frame_get_frame(frame3_backend);
+
+  UFTouch frame3_touch;
+  status = frame_frame_get_touch_by_id(frame3, 1, &frame3_touch);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  /* frame 4 */
+  UFBackendFrame frame4_backend = frame_backend_frame_create_next(frame3_backend);
+
+  status = frame_backend_frame_borrow_touch_by_id(frame4_backend, 1, &touch_backend);
+  ASSERT_EQ(UFStatusSuccess, status);
+  frame_backend_touch_set_ended(touch_backend);
+  status = frame_backend_frame_give_touch(frame4_backend, &touch_backend);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  UFFrame frame4 = frame_backend_frame_get_frame(frame4_backend);
+  UFTouch frame4_touch;
+  status = frame_frame_get_touch_by_id(frame4, 1, &frame4_touch);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  /* frame 5 */
+  UFBackendFrame frame5_backend = frame_backend_frame_create_next(frame4_backend);
+  UFFrame frame5 = frame_backend_frame_get_frame(frame5_backend);
+
+  /* Test the status of touch 1 throughout all frames */
+  ASSERT_EQ(UFTouchStateBegin, frame_touch_get_state(frame1_touch));
+  ASSERT_EQ(UFTouchStateUpdate, frame_touch_get_state(frame2_touch));
+  ASSERT_EQ(UFTouchStateUpdate, frame_touch_get_state(frame3_touch));
+  ASSERT_EQ(frame2_touch, frame3_touch);
+  ASSERT_EQ(UFTouchStateEnd, frame_touch_get_state(frame4_touch));
+  ASSERT_EQ(0, frame_frame_get_num_touches(frame5));
+
+  /* clean up */
+  frame_backend_frame_delete(frame1_backend);
+  frame_backend_frame_delete(frame2_backend);
+  frame_backend_frame_delete(frame3_backend);
+  frame_backend_frame_delete(frame4_backend);
+  frame_backend_frame_delete(frame5_backend);
 }
 
 TEST(Backend, Event)