Merge lp:~dandrader/grail/convert_tests into lp:grail

[Daniel d'Andrada]

Get rid of x11 specific code in grail implementation.

That way grail can be compiled with x11 dependencies and still process correctly frames that were generated via frame_backend.h instead of frame_x11.h.

Also use frame_backend.h instead of a frame mock in tests, which is a more realistic situation and also exercises the frame_backend.h API. It wouldn't be possible to do that if grail implementation still had frame_x11_* calls.

Get rid of x11 specific code in grail implementation.

That way grail can be compiled with x11 dependencies and still process correctly frames that were generated via frame_backend.h instead of frame_x11.h.

Also use frame_backend.h instead of a frame mock in tests, which is a more realistic situation and also exercises the frame_backend.h API. It wouldn't be possible to do that if grail implementation still had frame_x11_* calls.

[Stephen M. Webb (bregma)]

OK

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/grail-mbs-autolanding/6/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/grail-mbs-autolanding/./build=pbuilder,distribution=raring,flavor=amd64/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/grail-mbs-autolanding/./build=pbuilder,distribution=raring,flavor=i386/6/console

review: Needs Fixing (continuous-integration)

[lp:~dandrader/grail/convert_tests]

251. By Daniel d'Andrada on 2012-12-06

Get rid of x11 specific code in grail implementation.

That way grail can be compiled with x11 dependencies and still process correctly frames that were generated via frame_backend.h instead of frame_x11.h.

Also use frame_backend.h instead of a frame mock in tests, which is a more realistic situation and also exercises the frame_backend.h API. It wouldn't be possible to do that if grail implementation still had frame_x11_* calls.

Approved by Stephen M. Webb.

[Mathieu Trudel-Lapierre (cyphermox)]

Seems fine re: packaging; in this since, ack from me. I don't know why it conflicts in debian/changelog though.

Note that this would depwait until frame 2.5.0 is available in the archive.

review: Approve

=== modified file 'configure.ac'
--- configure.ac	2012-11-29 15:41:42 +0000
+++ configure.ac	2012-12-06 18:31:20 +0000
@@ -65,7 +65,7 @@
 #################################
 # check mandatory build dependencies
 
-PKG_CHECK_MODULES([FRAME], [frame >= 2.2.0])
+PKG_CHECK_MODULES([FRAME], [frame >= 2.5.0])
 
 #################################
 # debug builds

=== modified file 'debian/changelog'
--- debian/changelog	2012-12-04 11:32:11 +0000
+++ debian/changelog	2012-12-06 18:31:20 +0000
@@ -1,6 +1,9 @@
 grail (3.0.9daily12.12.04-0ubuntu1) UNRELEASED; urgency=low
 
   * Relicense under (L)GPL version 3 *only* (no +)
+  * Updated libframe version dependency to 2.5.0
+  * Use frame_backend.h instead of a frame mock in tests
+  * Get rid of x11 specific code in grail implementation
 
  -- Daniel d'Andrada <[e-mail]>  Tue, 04 Dec 2012 09:31:28 -0200
 

=== modified file 'debian/control'
--- debian/control	2012-11-28 12:48:12 +0000
+++ debian/control	2012-12-06 18:31:20 +0000
@@ -4,7 +4,7 @@
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: debhelper (>= 9),
                dh-autoreconf,
-               libframe-dev (>= 2.4.4),
+               libframe-dev (>= 2.5.0),
                libx11-dev (>= 1.4.99),
                libxext-dev (>= 1.3),
                libxi-dev (>= 1.5.99.2),

=== modified file 'src/handle.cpp'
--- src/handle.cpp	2012-11-20 20:13:00 +0000
+++ src/handle.cpp	2012-12-06 18:31:20 +0000
@@ -30,9 +30,6 @@
 #include <stdexcept>
 
 #include <oif/frame.h>
-#ifdef FRAME_X11_BACKEND
- #include <oif/frame_x11.h>
-#endif
 
 #include "atomic-recognizer.h"
 #include "event.h"
@@ -154,9 +151,7 @@
     if (frame_touch_get_state(touch) != UFTouchStateBegin)
       continue;
 
-#ifdef FRAME_X11_BACKEND
-    frame_x11_reject_touch(device, window_id, frame_touch_get_id(touch));
-#endif
+    frame_reject_touch(device, window_id, frame_touch_get_id(touch));
   }
 }
 

=== modified file 'src/touch.cpp'
--- src/touch.cpp	2012-11-20 20:13:00 +0000
+++ src/touch.cpp	2012-12-06 18:31:20 +0000
@@ -20,10 +20,6 @@
 
 #include "touch.h"
 
-#ifdef FRAME_X11_BACKEND
- #include <oif/frame_x11.h>
-#endif
-
 #include "log.h"
 
 namespace oif {
@@ -73,10 +69,8 @@
 
 void Touch::Accept() {
   LOG(Dbg) << "accepting touch " << id_ << "\n";
-#ifdef FRAME_X11_BACKEND
-  if (frame_x11_accept_touch(device_, window_id_, id_) != UFStatusSuccess)
+  if (frame_accept_touch(device_, window_id_, id_) != UFStatusSuccess)
     LOG(Err) << "touch " << id_ << " failed to be accepted\n";
-#endif
 
   accepted_ = true;
 }
@@ -84,10 +78,8 @@
 Touch::~Touch() {
   if (!accepted_) {
     LOG(Dbg) << "rejecting touch " << id_ << "\n";
-#ifdef FRAME_X11_BACKEND
-    if (frame_x11_reject_touch(device_, window_id_, id_) != UFStatusSuccess)
+    if (frame_reject_touch(device_, window_id_, id_) != UFStatusSuccess)
       LOG(Err) << "touch " << id_ << " failed to be rejected\n";
-#endif
   }
 }
 

=== modified file 'test/regular/Makefile.am'
--- test/regular/Makefile.am	2012-11-20 20:13:00 +0000
+++ test/regular/Makefile.am	2012-12-06 18:31:20 +0000
@@ -25,8 +25,6 @@
 
 check_regular_SOURCES = \
 	grail.cpp \
-	frame_mock.cpp \
-	frame_mock.h \
 	grail-fixture.cpp \
 	grail-fixture.h \
 	intermittent_3touch.cpp \
@@ -43,7 +41,8 @@
 	$(top_builddir)/src/.libs/libgrail.a \
 	$(top_builddir)/test/gtest/libgtest_grail.a \
 	$(COVERAGE_LIBS) \
-	$(GTEST_LIBS)
+	$(GTEST_LIBS) \
+	$(FRAME_LIBS)
 
 check_regular_CPPFLAGS = \
 	--std=c++0x \

=== removed file 'test/regular/frame_mock.cpp'
--- test/regular/frame_mock.cpp	2012-11-21 13:31:12 +0000
+++ test/regular/frame_mock.cpp	1970-01-01 00:00:00 +0000
@@ -1,254 +0,0 @@
-#include "frame_mock.h"
-
-extern "C" {
-
-/*****************************************************************************
- * Event
- *****************************************************************************/
-
-UFEventType frame_event_get_type(UFEvent self)
-{
-  return self->type;
-}
-
-UFStatus frame_event_get_property(UFEvent self, UFEventProperty property,
-                                  void *value)
-{
-  UFStatus status = UFStatusErrorUnknownProperty;
-
-  if (property == UFEventPropertyFrame && self->frame_ptr)
-  {
-    *((UFFrame*)value) = self->frame_ptr.get();
-    status = UFStatusSuccess;
-  }
-  else if (property == UFEventPropertyDevice && self->device_ptr)
-  {
-    *((UFDevice*)value) = self->device_ptr.get();
-    status = UFStatusSuccess;
-  }
-
-  return status;
-}
-
-uint64_t frame_event_get_time(UFEvent self)
-{
-  return self->time;
-}
-
-void frame_event_ref(UFEvent self)
-{
-  ++self->ref_count;
-}
-
-void frame_event_unref(UFEvent self)
-{
-  --self->ref_count;
-
-  if (self->ref_count == 0)
-    delete self;
-}
-
-/*****************************************************************************
- * Frame
- *****************************************************************************/
-
-UFStatus frame_frame_get_touch_by_index(UFFrame self, unsigned int index,
-                                        UFTouch *touch)
-{
-  UFStatus status;
-
-  if (index < self->touches.size())
-  {
-    *touch = &(self->touches[index]);
-    status = UFStatusSuccess;
-  }
-  else
-  {
-    status = UFStatusErrorInvalidTouch;
-  }
-
-  return status;
-}
-
-UFStatus frame_frame_get_touch_by_id(UFFrame self, UFTouchId touch_id,
-                                     UFTouch* touch_pointer)
-{
-  UFStatus status = UFStatusErrorInvalidTouch;
-
-  for (struct UFTouch_ &touch : self->touches)
-  {
-    if (touch.id == touch_id)
-    {
-      *touch_pointer = &touch;
-      status = UFStatusSuccess;
-      break;
-    }
-  }
-
-  return status;
-}
-
-uint32_t frame_frame_get_num_touches(UFFrame self)
-{
-  return self->touches.size();
-}
-
-UFDevice frame_frame_get_device(UFFrame self)
-{
-  return self->device_ptr.get();
-}
-
-UFWindowId frame_frame_get_window_id(UFFrame self)
-{
-  return self->window_id;
-}
-
-/*****************************************************************************
- * Touch
- *****************************************************************************/
-
-UFStatus frame_touch_get_property(UFTouch self, UFTouchProperty property,
-                                  void *value)
-{
-  UFStatus status;
-
-  switch (property)
-  {
-    case UFTouchPropertyOwned:
-      *((int*)value) = self->owned;
-      status = UFStatusSuccess;
-      break;
-
-    case UFTouchPropertyPendingEnd:
-      *((int*)value) = self->pending_end;
-      status = UFStatusSuccess;
-      break;
-
-    default:
-      status = UFStatusErrorUnknownProperty;
-  }
-
-  return status;
-}
-
-UFTouchId frame_touch_get_id(UFTouch self)
-{
-  return self->id;
-}
-
-UFTouchState frame_touch_get_state(UFTouch self)
-{
-  return self->state;
-}
-
-float frame_touch_get_window_x(UFTouch self)
-{
-  return self->window_x;
-}
-
-float frame_touch_get_window_y(UFTouch self)
-{
-  return self->window_y;
-}
-
-float frame_touch_get_device_x(UFTouch self)
-{
-  return self->device_x;
-}
-
-float frame_touch_get_device_y(UFTouch self)
-{
-  return self->device_y;
-}
-
-uint64_t frame_touch_get_time(UFTouch self)
-{
-  return self->time;
-}
-
-uint64_t frame_touch_get_start_time(UFTouch self)
-{
-  return self->start_time;
-}
-
-/*****************************************************************************
- * Device
- *****************************************************************************/
-
-UFStatus frame_device_get_property(UFDevice self, UFDeviceProperty property,
-                                   void *value)
-{
-  UFStatus status;
-
-  switch (property)
-  {
-    case UFDevicePropertyDirect:
-      *((int*)value) = self->direct;
-      status = UFStatusSuccess;
-      break;
-
-    default:
-      status = UFStatusErrorUnknownProperty;
-  }
-
-  return status;
-}
-
-UFStatus frame_device_get_axis_by_type(UFDevice self, UFAxisType axis_type,
-                                       UFAxis *axis_pointer)
-{
-  UFStatus status = UFStatusErrorInvalidAxis;
-
-  for (struct UFAxis_ &axis : self->axes)
-  {
-    if (axis.type == axis_type)
-    {
-      *axis_pointer = &axis;
-      status = UFStatusSuccess;
-      break;
-    }
-  }
-
-  return status;
-}
-
-float frame_device_get_window_resolution_x(UFDevice self)
-{
-  return self->window_resolution_x;
-}
-
-float frame_device_get_window_resolution_y(UFDevice self)
-{
-  return self->window_resolution_y;
-}
-
-/*****************************************************************************
- * Axis
- *****************************************************************************/
-
-float frame_axis_get_resolution(UFAxis self)
-{
-  return self->resolution;
-}
-
-/*****************************************************************************
- * Frame X11
- *****************************************************************************/
-
-#ifdef FRAME_X11_BACKEND
-UFStatus frame_x11_accept_touch(UFDevice device, UFWindowId window,
-                                UFTouchId touch_id)
-{
-  device->x11_touch_acceptance[window][touch_id] = true;
-  return UFStatusSuccess;
-}
-
-UFStatus frame_x11_reject_touch(UFDevice device, UFWindowId window,
-                                UFTouchId touch_id)
-{
-  device->x11_touch_acceptance[window][touch_id] = false;
-  return UFStatusSuccess;
-}
-#endif // FRAME_X11_BACKEND
-
-} // extern "C"

=== removed file 'test/regular/frame_mock.h'
--- test/regular/frame_mock.h	2012-11-21 13:31:12 +0000
+++ test/regular/frame_mock.h	1970-01-01 00:00:00 +0000
@@ -1,66 +0,0 @@
-#ifndef FRAME_MOCK_H
-#define FRAME_MOCK_H
-
-#include <oif/frame.h>
-#include <map>
-#include <vector>
-#include <memory>
-
-extern "C" {
-
-struct UFHandle_
-{
-  int fd;
-};
-
-struct UFEvent_
-{
-  UFEvent_() {ref_count = 1;}
-  UFEventType type;
-  std::shared_ptr<struct UFDevice_> device_ptr;
-  std::unique_ptr<struct UFFrame_> frame_ptr;
-  uint64_t time;
-  int ref_count;
-};
-
-struct UFFrame_
-{
-  std::shared_ptr<struct UFDevice_> device_ptr;
-  UFWindowId window_id;
-  std::vector<struct UFTouch_> touches;
-};
-
-struct UFTouch_
-{
-  UFTouchId id;
-  UFTouchState state;
-  float window_x;
-  float window_y;
-  float device_x;
-  float device_y;
-  uint64_t time;
-  uint64_t start_time;
-  int owned;
-  int pending_end;
-};
-
-struct UFDevice_
-{
-  int direct;
-  std::vector<struct UFAxis_> axes;
-  float window_resolution_x;
-  float window_resolution_y;
-#ifdef FRAME_X11_BACKEND
-  std::map<UFWindowId, std::map<UFTouchId, bool> > x11_touch_acceptance;
-#endif
-};
-
-struct UFAxis_
-{
-  UFAxisType type;
-  float resolution;
-};
-
-} // extern "C"
-
-#endif

=== modified file 'test/regular/grail-fixture.cpp'
--- test/regular/grail-fixture.cpp	2012-07-23 13:11:21 +0000
+++ test/regular/grail-fixture.cpp	2012-12-06 18:31:20 +0000
@@ -1,72 +1,58 @@
 #include "grail-fixture.h"
 
-void GrailTest::SendFrameEvent(
-    uint64_t time,
-    UFWindowId window_id,
-    const struct UFTouch_ &touch_struct)
-{
-  std::vector<struct UFTouch_> touches;
-  touches.push_back(touch_struct);
-  SendFrameEvent(time, window_id, touches);
-}
-
-void GrailTest::SendFrameEvent(
-    uint64_t time,
-    UFWindowId window_id,
-    std::vector<struct UFTouch_> &touches)
-{
-  UFFrame frame = new struct UFFrame_;
-  frame->device_ptr = device_ptr;
-  frame->window_id = window_id;
-  frame->touches = touches;
-
-  UFEvent frame_event = new struct UFEvent_;
-  frame_event->type = UFEventTypeFrame;
-  frame_event->time = time;
-  frame_event->frame_ptr.reset(std::move(frame));
-
-  grail_process_frame_event(grail_handle, frame_event);
-  frame_event_unref(frame_event);
-  frame_event = nullptr;
+void GrailTest::SendFrameEvent(uint64_t time, UFBackendFrame frame)
+{
+  UFEvent event = frame_event_new();
+  frame_event_set_type(event, UFEventTypeFrame);
+  frame_event_set_frame(event, frame);
+  frame_event_set_time(event, time);
+
+  grail_process_frame_event(grail_handle, event);
+  frame_event_unref(event);
+  event = nullptr;
+
+  if (previous_frame_)
+    frame_backend_frame_delete(previous_frame_);
+  previous_frame_ = frame;
 }
 
 void GrailTest::SendDeviceAddedEvent(uint64_t time)
 {
-  UFEvent frame_event = new struct UFEvent_;
-  frame_event->type = UFEventTypeDeviceAdded;
-  frame_event->time = time;
-  frame_event->device_ptr = device_ptr;
+  UFEvent event = frame_event_new();
+  frame_event_set_type(event, UFEventTypeDeviceAdded);
+  frame_event_set_time(event, time);
+  frame_event_set_device(event, device_);
 
-  grail_process_frame_event(grail_handle, frame_event);
-  frame_event_unref(frame_event);
-  frame_event = nullptr;
+  grail_process_frame_event(grail_handle, event);
+  frame_event_unref(event);
+  event = nullptr;
 }
 
-void GrailTest::FillFakeDeviceStruct()
+void GrailTest::CreateFakeDevice()
 {
-  struct UFAxis_ axis_x_struct;
-  axis_x_struct.type = UFAxisTypeX;
-  axis_x_struct.resolution = 3764.70;
-
-  struct UFAxis_ axis_y_struct;
-  axis_y_struct.type = UFAxisTypeY;
-  axis_y_struct.resolution = 3764.70;
-
-  device_ptr.reset(new struct UFDevice_);
-  device_ptr->direct = 1;
-  device_ptr->axes.push_back(axis_x_struct);
-  device_ptr->axes.push_back(axis_y_struct);
+  device_ = frame_backend_device_new();
+
+  frame_backend_device_add_axis(device_,
+                                UFAxisTypeX,
+                                0, 10000, 3764.70);
+
+  frame_backend_device_add_axis(device_,
+                                UFAxisTypeY,
+                                0, 10000, 3764.70);
+
+  frame_backend_device_set_direct(device_, 1);
+
   /* pixels/m */
-  device_ptr->window_resolution_x = 3764.70;
-  device_ptr->window_resolution_y = 3764.70;
+  frame_backend_device_set_window_resolution(device_, 3764.70, 3764.70);
 }
 
 UGSubscription GrailTest::CreateSubscription(
     unsigned int num_touches, UGGestureTypeMask gesture_mask,
-    UFDevice device, UFWindowId window_id)
+    UFWindowId window_id)
 {
   UGStatus status;
   UGSubscription subscription = nullptr;
+  UFDevice uf_device = frame_backend_device_get_device(device_);
 
   status = grail_subscription_new(&subscription);
   if (status != UGStatusSuccess)
@@ -77,7 +63,7 @@
 
   status = grail_subscription_set_property(subscription,
                                            UGSubscriptionPropertyDevice,
-                                           &device);
+                                           &uf_device);
   if (status != UGStatusSuccess)
   {
     ADD_FAILURE() << "failed to set device subscription";
@@ -150,75 +136,111 @@
   BeginTouchWindowCoords(touch_id, touch_id * 10.0f, 0.0f);
 }
 
+namespace
+{
+void IncrementFrameActiveTouches(UFBackendFrame frame_backend)
+{
+  UFFrame frame = frame_backend_frame_get_frame(frame_backend);
+  unsigned int active_touches;
+  frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
+  frame_backend_frame_set_active_touches(frame_backend, active_touches + 1);
+}
+
+} // anonymous namespace
+
 void GrailTest::BeginTouchWindowCoords(int touch_id, float window_x, float window_y)
 {
-  struct UFTouch_ touch_struct;
-  touch_struct.id = touch_id;
-  touch_struct.state = UFTouchStateBegin;
-  touch_struct.time = time;
-  touch_struct.start_time = touch_struct.time;
-  touch_struct.window_x = window_x;
-  touch_struct.window_y = window_y;
-  touch_struct.owned = 0;
-  touch_struct.pending_end = 0;
-
-  touches.push_back(touch_struct);
-
-  SendFrameEvent(time, fake_window_id, touches);
-
-  // leave it in a neutral state for next uses of touches vector
-  touches[touches.size()-1].state = UFTouchStateUpdate;
+  UFBackendTouch touch = frame_backend_touch_new();
+  frame_backend_touch_set_id(touch, touch_id);
+  frame_backend_touch_set_time(touch, time);
+  frame_backend_touch_set_start_time(touch, time);
+  frame_backend_touch_set_window_pos(touch, window_x, window_y);
+  frame_backend_touch_set_owned(touch, 0);
+  frame_backend_touch_set_pending_end(touch, 0);
+
+  UFBackendFrame frame;
+  if (previous_frame_)
+    frame = frame_backend_frame_create_next(previous_frame_);
+  else
+    frame = frame_backend_frame_new();
+
+  frame_backend_frame_set_device(frame, device_);
+
+  frame_backend_frame_give_touch(frame, &touch);
+  IncrementFrameActiveTouches(frame);
+  frame_backend_frame_set_window_id(frame, fake_window_id);
+
+  SendFrameEvent(time, frame);
 }
 
 void GrailTest::GiveTouchOwnership(int touch_id)
 {
-  auto iterator = FindTouch(touch_id);
-  iterator->state = UFTouchStateUpdate;
-  iterator->owned = 1; // ownership will trigger delivery of grail events.
-  iterator->time = time;
-
-  SendFrameEvent(time, fake_window_id, touches);
-}
-
-void GrailTest::SetTouchWindowCoords(int touch_id, float window_x, float window_y)
-{
-  auto iterator = FindTouch(touch_id);
-  iterator->window_x = window_x;
-  iterator->window_y = window_y;
-}
-
-void GrailTest::UpdateTouches()
-{
-  for (struct UFTouch_ &touch : touches)
-  {
-    touch.time = time;
-  }
-  SendFrameEvent(time, fake_window_id, touches);
+  std::function<void(UFBackendTouch)> update_func =
+    [](UFBackendTouch touch)
+    {
+      frame_backend_touch_set_owned(touch, 1);
+    };
+
+  UpdateTouch(touch_id, update_func);
+}
+
+void GrailTest::UpdateTouch(int touch_id,
+                            std::function< void(UFBackendTouch) >& update_func)
+{
+  assert(previous_frame_); // error would be in the test itself
+
+  UFBackendFrame frame = frame_backend_frame_create_next(previous_frame_);
+  frame_backend_frame_set_device(frame, device_);
+  frame_backend_frame_set_window_id(frame, fake_window_id);
+
+  UFStatus status;
+  UFBackendTouch touch;
+  status = frame_backend_frame_borrow_touch_by_id(frame, touch_id, &touch);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  update_func(touch);
+  frame_backend_touch_set_time(touch, time);
+
+  status = frame_backend_frame_give_touch(frame, &touch);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  SendFrameEvent(time, frame);
+}
+
+void GrailTest::SetTouchWindowCoords(UFBackendFrame frame,
+                                     int touch_id, float window_x, float window_y)
+{
+  UFStatus status;
+  UFBackendTouch touch;
+  status = frame_backend_frame_borrow_touch_by_id(frame, touch_id, &touch);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  frame_backend_touch_set_window_pos(touch, window_x, window_y);
+
+  status = frame_backend_frame_give_touch(frame, &touch);
+  ASSERT_EQ(UFStatusSuccess, status);
+}
+
+void GrailTest::SendTouchPendingEnd(int touch_id)
+{
+  std::function<void(UFBackendTouch)> update_func =
+    [](UFBackendTouch touch)
+    {
+      frame_backend_touch_set_pending_end(touch, 1);
+    };
+
+  UpdateTouch(touch_id, update_func);
 }
 
 void GrailTest::EndTouch(int touch_id)
 {
-  auto iterator = FindTouch(touch_id);
-  iterator->state = UFTouchStateEnd;
-  iterator->time = time;
-
-  SendFrameEvent(time, fake_window_id, touches);
-
-  touches.erase(iterator);
-}
-
-std::vector<struct UFTouch_>::iterator GrailTest::FindTouch(unsigned int touch_id)
-{
-  std::vector<struct UFTouch_>::iterator it = touches.begin();
-
-  while (it != touches.end())
-  {
-    if (it->id == touch_id)
-      return it;
-    ++it;
-  }
-
-  return it;
+  std::function<void(UFBackendTouch)> update_func =
+    [](UFBackendTouch touch)
+    {
+      frame_backend_touch_set_ended(touch);
+    };
+
+  UpdateTouch(touch_id, update_func);
 }
 
 void GrailTest::ProcessGrailEvents()

=== modified file 'test/regular/grail-fixture.h'
--- test/regular/grail-fixture.h	2012-08-27 21:52:42 +0000
+++ test/regular/grail-fixture.h	2012-12-06 18:31:20 +0000
@@ -3,8 +3,9 @@
 
 #include <gtest/gtest.h>
 #include <oif/grail.h>
-#include "frame_mock.h"
+#include <oif/frame_backend.h>
 
+#include <functional>
 #include <list>
 #include <set>
 
@@ -27,41 +28,38 @@
   virtual void SetUp()
   {
     grail_handle = NULL;
-    FillFakeDeviceStruct();
+    previous_frame_ = nullptr;
+    CreateFakeDevice();
   }
 
   virtual void TearDown()
   {
     if (grail_handle)
       grail_delete(grail_handle);
+
+    if (previous_frame_)
+      frame_backend_frame_delete(previous_frame_);
+
+    frame_backend_device_delete(device_);
   }
 
   protected:
 
   UGSubscription CreateSubscription(unsigned int num_touches,
-      UGGestureTypeMask gesture_mask, UFDevice device, UFWindowId window_id);
+      UGGestureTypeMask gesture_mask, UFWindowId window_id);
 
-  void FillFakeDeviceStruct();
-  void SendDeviceAddedEvent();
-  void SendFrameEvent(
-      uint64_t time,
-      UFWindowId window_id,
-      const struct UFTouch_ &touch_struct);
-  void SendFrameEvent(
-      uint64_t time,
-      UFWindowId window_id,
-      std::vector<struct UFTouch_> &touches);
+  void CreateFakeDevice();
   void SendDeviceAddedEvent(uint64_t time);
+  void SendFrameEvent(uint64_t time, UFBackendFrame frame);
 
   void BeginTouch(int touch_id);
   void BeginTouchWindowCoords(int touch_id, float window_x, float window_y);
   void GiveTouchOwnership(int touch_id);
-  void SetTouchWindowCoords(int touch_id, float window_x, float window_y);
-  /* Updates the time of all touches in the "touches" vector and sends that vector
-     in a frame event to grail */
-  void UpdateTouches();
+  void SetTouchWindowCoords(UFBackendFrame frame,
+                            int touch_id, float window_x, float window_y);
+  void SendTouchPendingEnd(int touch_id);
   void EndTouch(int touch_id);
-  std::vector<struct UFTouch_>::iterator FindTouch(unsigned int touch_id);
+  void UpdateTouch(int touch_id, std::function< void(UFBackendTouch) >& update_func);
 
   /* Fetches and processes all pending grail events, updating grail_gestures
      list accordingly. */
@@ -75,11 +73,11 @@
   void PrintSlice(UGSlice slice);
 
   UGHandle grail_handle;
-  std::shared_ptr<struct UFDevice_> device_ptr;
+  UFBackendDevice device_;
 
   uint64_t time;
   UFWindowId fake_window_id;
-  std::vector<struct UFTouch_> touches;
+  UFBackendFrame previous_frame_;
 
   /*
     A representation of the currently active gestures according to the grail events

=== modified file 'test/regular/intermittent_3touch.cpp'
--- test/regular/intermittent_3touch.cpp	2012-08-27 21:41:43 +0000
+++ test/regular/intermittent_3touch.cpp	2012-12-06 18:31:20 +0000
@@ -25,7 +25,7 @@
   SendDeviceAddedEvent(time);
 
   UGSubscription subscription =
-    CreateSubscription(3, UGGestureTypeTouch, device_ptr.get(), fake_window_id);
+    CreateSubscription(3, UGGestureTypeTouch, fake_window_id);
   if (!subscription) return;
 
   time = 20531903;

=== modified file 'test/regular/one-touch-gest-finished.cpp'
--- test/regular/one-touch-gest-finished.cpp	2012-08-27 21:41:43 +0000
+++ test/regular/one-touch-gest-finished.cpp	2012-12-06 18:31:20 +0000
@@ -10,7 +10,7 @@
 TEST_F(SingleTouchGestureTest, QuickTapEndsWithConstructionFinished)
 {
   UGStatus status;
-  UFWindowId fake_window_id = 321;
+  fake_window_id = 321;
   uint64_t time = 1234;
 
   status = grail_new(&grail_handle);
@@ -19,30 +19,14 @@
   SendDeviceAddedEvent(time);
 
   UGSubscription subscription =
-    CreateSubscription(1, UGGestureTypeTouch, device_ptr.get(), fake_window_id);
+    CreateSubscription(1, UGGestureTypeTouch, fake_window_id);
   if (!subscription) return;
 
   time += 10;
-  struct UFTouch_ touch_struct;
-  touch_struct.id = 1;
-  touch_struct.state = UFTouchStateBegin;
-  touch_struct.window_x = 10.0f;
-  touch_struct.window_y = 10.0f;
-  touch_struct.device_x = 100.0f;
-  touch_struct.device_y = 100.0f;
-  touch_struct.time = time;
-  touch_struct.start_time = touch_struct.time;
-  touch_struct.owned = 0;
-  touch_struct.pending_end = 0;
-
-  SendFrameEvent(time, fake_window_id, touch_struct);
+  BeginTouch(1);
 
   time += 10;
-  touch_struct.state = UFTouchStateUpdate;
-  touch_struct.owned = 1; // ownership will trigger delivery of grail events.
-  touch_struct.time = time;
-
-  SendFrameEvent(time, fake_window_id, touch_struct);
+  GiveTouchOwnership(1);
 
   // There should now be two grail events, corresponding to the frame
   // event that were sent, waiting to be processed.
@@ -80,10 +64,7 @@
   // now end the touch
 
   time += 10;
-  touch_struct.state = UFTouchStateEnd;
-  touch_struct.time = time;
-
-  SendFrameEvent(time, fake_window_id, touch_struct);
+  EndTouch(1);
 
   // An end event should come and its "construction finished" property should be true
 

=== modified file 'test/regular/pending-end.cpp'
--- test/regular/pending-end.cpp	2012-08-27 21:41:43 +0000
+++ test/regular/pending-end.cpp	2012-12-06 18:31:20 +0000
@@ -18,7 +18,7 @@
 
   UGSubscription sub_3touch =
     CreateSubscription(3, UGGestureTypeTouch | UGGestureTypeDrag | UGGestureTypePinch,
-                       device_ptr.get(), fake_window_id);
+                       fake_window_id);
   ASSERT_NE(nullptr, sub_3touch);
 
   time = 13688369;
@@ -41,15 +41,17 @@
   for (int i=1; i<=4; ++i)
   {
     time += 100;
-    SetTouchWindowCoords(1, 30.0f, i*10.0f);
-    SetTouchWindowCoords(2, 40.0f, i*10.0f);
-    SetTouchWindowCoords(3, 50.0f, i*10.0f);
-    UpdateTouches();
+    UFBackendFrame frame = frame_backend_frame_create_next(previous_frame_);
+    frame_backend_frame_set_device(frame, device_);
+    frame_backend_frame_set_window_id(frame, fake_window_id);
+    SetTouchWindowCoords(frame, 1, 30.0f, i*10.0f);
+    SetTouchWindowCoords(frame, 2, 40.0f, i*10.0f);
+    SetTouchWindowCoords(frame, 3, 50.0f, i*10.0f);
+    SendFrameEvent(time, frame);
   }
 
   time = 13688877;
-  FindTouch(1)->pending_end = 1;
-  UpdateTouches();
+  SendTouchPendingEnd(1);
 
   ProcessGrailEvents();
   // no gesture slices yet since not all touches are owned

=== modified file 'test/regular/still-gest-finishes.cpp'
--- test/regular/still-gest-finishes.cpp	2012-08-27 21:41:43 +0000
+++ test/regular/still-gest-finishes.cpp	2012-12-06 18:31:20 +0000
@@ -19,30 +19,14 @@
   SendDeviceAddedEvent(time);
 
   UGSubscription subscription =
-    CreateSubscription(1, UGGestureTypeTouch, device_ptr.get(), fake_window_id);
+    CreateSubscription(1, UGGestureTypeTouch, fake_window_id);
   if (!subscription) return;
 
   time += 10;
-  struct UFTouch_ touch_struct;
-  touch_struct.id = 1;
-  touch_struct.state = UFTouchStateBegin;
-  touch_struct.window_x = 10.0f;
-  touch_struct.window_y = 10.0f;
-  touch_struct.device_x = 100.0f;
-  touch_struct.device_y = 100.0f;
-  touch_struct.time = time;
-  touch_struct.start_time = touch_struct.time;
-  touch_struct.owned = 0;
-  touch_struct.pending_end = 0;
-
-  SendFrameEvent(time, fake_window_id, touch_struct);
+  BeginTouch(1);
 
   time += 10;
-  touch_struct.state = UFTouchStateUpdate;
-  touch_struct.owned = 1; // ownership will trigger delivery of grail events.
-  touch_struct.time = time;
-
-  SendFrameEvent(time, fake_window_id, touch_struct);
+  GiveTouchOwnership(1); // ownership will trigger delivery of grail events.
 
   // There should now be two grail events, corresponding to the frame
   // event that were sent, waiting to be processed.