Merge lp:~kdub/mir/add-sync-support into lp:~mir-team/mir/trunk

[Kevin DuBois]

add sync driver support to the android client

fixes: https://bugs.launchpad.net/mir/+bug/1117841

android uses the 'sync' driver available on the android kernel for additional synchronization with the driver. This support was added in the upgrade to the native window type for android. The requirement on us is that we wait on the sync object (via ioctl) and that we close the sync object. After we do this, we get stable client accelerated rendering.

The sync driver is open source in the android kernel. However, the android kernel headers are not available as a package (correct me if I'm wrong :) ), so I scraped the ioctl value and put it in the source, like the android sources do.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:504
http://jenkins.qa.ubuntu.com/job/mir-ci/60/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/61//console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/60//rebuild/?

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

243 + SyncFence(int fd);
244 +
245 + //override using real ioctl's with something else. useful for injecting mocks
246 + SyncFence(int fd, std::shared_ptr<IoctlWrapper> const& wrapper);

My preference (as stated in other MPs, too), is to not use default arguments or overloaded constructors as a way to provide default dependencies. The reasons are reduced design clarity (does SyncFence depend on IoctlWrapper or not?), and the introduction of different (even if trivially different) code paths, some of which are not as well tested as the others.

My suggestion is to keep only the "full" constructor and provide an IoctlWrapper implementation at SyncFence construction in mir_native_window.cpp.

225 +class IoctlWrapper
226 +{
233 +class AndroidFence
234 +{

Do we need the copy constructor and assignment operator for these?

252 + std::shared_ptr<IoctlWrapper> ioctl_wrapper;

shared_ptr const

466 +

Nitpick: Do we need this added space here?

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

Also, I wonder if something like this would be a better fit than IoctlWrapper:

FenceFDWrapper
{
    virtual void sync() = 0;
    virtual void close() = 0;
};

FenceFDImpl : FenceFDWrapper
{
   FenceFDImpl(int fd) : fd{fd} {}

   void sync() { if (fd >= 0) ioctl(fd, SYNC_IOC_WAIT, &timeout); }
   void close() { close(fd) }
};

[Alan Griffiths (alan-griffiths)]

> 243 + SyncFence(int fd);
> 244 +
> 245 + //override using real ioctl's with something else. useful for
> injecting mocks
> 246 + SyncFence(int fd, std::shared_ptr<IoctlWrapper> const& wrapper);
>
> My preference (as stated in other MPs, too), is to not use default arguments
> or overloaded constructors as a way to provide default dependencies. The
> reasons are reduced design clarity (does SyncFence depend on IoctlWrapper or
> not?), and the introduction of different (even if trivially different) code
> paths, some of which are not as well tested as the others.
>
> My suggestion is to keep only the "full" constructor and provide an
> IoctlWrapper implementation at SyncFence construction in
> mir_native_window.cpp.
>
> 225 +class IoctlWrapper
> 226 +{
> 233 +class AndroidFence
> 234 +{
>
> Do we need the copy constructor and assignment operator for these?
>
> 252 + std::shared_ptr<IoctlWrapper> ioctl_wrapper;
>
> shared_ptr const
>
> 466 +
>
> Nitpick: Do we need this added space here?

+1

Also, not directly aimed at this MP - why don't we have a FileHandle type instead of passing naked ints around?

review: Needs Fixing

[Kevin DuBois (kdub)]

> 243 + SyncFence(int fd);
> 244 +
> 245 + //override using real ioctl's with something else. useful for
> injecting mocks
> 246 + SyncFence(int fd, std::shared_ptr<IoctlWrapper> const& wrapper);
>
> My preference (as stated in other MPs, too), is to not use default arguments
> or overloaded constructors as a way to provide default dependencies. The
> reasons are reduced design clarity (does SyncFence depend on IoctlWrapper or
> not?), and the introduction of different (even if trivially different) code
> paths, some of which are not as well tested as the others.
>
> My suggestion is to keep only the "full" constructor and provide an
> IoctlWrapper implementation at SyncFence construction in
> mir_native_window.cpp.

I went with this suggestion over the FenceFDWrapper suggestion. I wanted to test right at the point that we call close/ioctl, so we can test how we handle invalid fd's directly.

>
> 225 +class IoctlWrapper
> 226 +{
> 233 +class AndroidFence
> 234 +{
>
> Do we need the copy constructor and assignment operator for these?

no, i have deleted copy/assign

>
> 252 + std::shared_ptr<IoctlWrapper> ioctl_wrapper;
>
> shared_ptr const
>
> 466 +
>
> Nitpick: Do we need this added space here?
addressed, (plus made the 'int fd' const)

[Kevin DuBois (kdub)]

>
> +1
>
> Also, not directly aimed at this MP - why don't we have a FileHandle type
> instead of passing naked ints around?

My intention with SyncFence was to wrap the FD as soon as we got it. SyncFence is more specialized than a generic type, but I think that's ok for now

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:507
http://jenkins.qa.ubuntu.com/job/mir-ci/73/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/74/console
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/74/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/73/rebuild

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Looks good overall. Some style nitpicks: https://code.launchpad.net/~mir-team/mir/add-sync-support/+merge/153301

(It was quicker to fix the code than propose the fixes :))

[Alan Griffiths (alan-griffiths)]

> Looks good overall. Some style nitpicks: https://code.launchpad.net/~mir-
> team/mir/add-sync-support/+merge/153301
>
> (It was quicker to fix the code than propose the fixes :))

With that tidy-up I'd be satisfied.

review: Abstain

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:508
http://jenkins.qa.ubuntu.com/job/mir-ci/84/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/85/console
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/85/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/84/rebuild

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2013-03-13 11:24:59 +0000
+++ src/client/CMakeLists.txt	2013-03-14 15:40:25 +0000
@@ -59,6 +59,7 @@
   android/android_client_platform.cpp
   android/mir_native_window.cpp
   android/client_surface_interpreter.cpp
+  android/syncfence.cpp
   ${CLIENT_SOURCES}
 )
 endif()

=== modified file 'src/client/android/android_driver_interpreter.h'
--- src/client/android/android_driver_interpreter.h	2013-03-12 15:27:46 +0000
+++ src/client/android/android_driver_interpreter.h	2013-03-14 15:40:25 +0000
@@ -31,7 +31,7 @@
 {
 public:
     virtual ANativeWindowBuffer* driver_requests_buffer() = 0;
-    virtual void driver_returns_buffer(ANativeWindowBuffer*, int fence_fd) = 0;
+    virtual void driver_returns_buffer(ANativeWindowBuffer*) = 0;
     virtual void dispatch_driver_request_format(int format) = 0;
     virtual int  driver_requests_info(int key) const = 0;
 protected:

=== modified file 'src/client/android/client_surface_interpreter.cpp'
--- src/client/android/client_surface_interpreter.cpp	2013-03-12 15:27:46 +0000
+++ src/client/android/client_surface_interpreter.cpp	2013-03-14 15:40:25 +0000
@@ -39,7 +39,7 @@
 
 static void empty(MirSurface * /*surface*/, void * /*client_context*/)
 {}
-void mcla::ClientSurfaceInterpreter::driver_returns_buffer(ANativeWindowBuffer*, int /*fence_fd*/)
+void mcla::ClientSurfaceInterpreter::driver_returns_buffer(ANativeWindowBuffer*)
 {
     mir_wait_for(surface.next_buffer(empty, NULL));
 }

=== modified file 'src/client/android/client_surface_interpreter.h'
--- src/client/android/client_surface_interpreter.h	2013-03-12 15:27:46 +0000
+++ src/client/android/client_surface_interpreter.h	2013-03-14 15:40:25 +0000
@@ -35,7 +35,7 @@
     explicit ClientSurfaceInterpreter(ClientSurface& surface);
 
     ANativeWindowBuffer* driver_requests_buffer();
-    void driver_returns_buffer(ANativeWindowBuffer*, int fence_fd);
+    void driver_returns_buffer(ANativeWindowBuffer*);
     void dispatch_driver_request_format(int format);
     int  driver_requests_info(int key) const;
 private:

=== modified file 'src/client/android/mir_native_window.cpp'
--- src/client/android/mir_native_window.cpp	2013-03-12 16:43:03 +0000
+++ src/client/android/mir_native_window.cpp	2013-03-14 15:40:25 +0000
@@ -18,12 +18,30 @@
 
 #include "mir_native_window.h"
 #include "android_driver_interpreter.h"
+#include "syncfence.h"
+
+#include <unistd.h>
+#include <sys/ioctl.h>
 
 namespace mcl=mir::client;
 namespace mcla=mir::client::android;
 
 namespace
 {
+
+class IoctlControl : public mcla::IoctlWrapper
+{
+public:
+    int ioctl(int fd, unsigned long int request, int* timeout) const
+    {
+        return ::ioctl(fd, request, timeout);
+    }
+    int close(int fd) const
+    {
+        return ::close(fd);
+    }
+};
+
 static int query_static(const ANativeWindow* anw, int key, int* value);
 static int perform_static(ANativeWindow* anw, int key, ...);
 static int setSwapInterval_static (struct ANativeWindow* window, int interval);
@@ -82,14 +100,18 @@
                        struct ANativeWindowBuffer* buffer)
 {
     auto self = static_cast<mcla::MirNativeWindow*>(window);
-    return self->queueBuffer(buffer, -1);
+    auto ioctl_control = std::make_shared<IoctlControl>();
+    auto fence = std::make_shared<mcla::SyncFence>(-1, ioctl_control);
+    return self->queueBuffer(buffer, fence);
 }
 
 int queueBuffer_static(struct ANativeWindow* window,
                        struct ANativeWindowBuffer* buffer, int fence_fd)
 {
     auto self = static_cast<mcla::MirNativeWindow*>(window);
-    return self->queueBuffer(buffer, fence_fd);
+    auto ioctl_control = std::make_shared<IoctlControl>();
+    auto fence = std::make_shared<mcla::SyncFence>(fence_fd, ioctl_control);
+    return self->queueBuffer(buffer, fence);
 
 }
 
@@ -146,9 +168,10 @@
     return 0;
 }
 
-int mcla::MirNativeWindow::queueBuffer(struct ANativeWindowBuffer* buffer, int fence_fd)
+int mcla::MirNativeWindow::queueBuffer(struct ANativeWindowBuffer* buffer, std::shared_ptr<mcla::AndroidFence> const& fence)
 {
-    driver_interpreter->driver_returns_buffer(buffer, fence_fd);
+    fence->wait();
+    driver_interpreter->driver_returns_buffer(buffer);
     return 0;
 }
 

=== modified file 'src/client/android/mir_native_window.h'
--- src/client/android/mir_native_window.h	2013-03-12 16:43:03 +0000
+++ src/client/android/mir_native_window.h	2013-03-14 15:40:25 +0000
@@ -30,6 +30,7 @@
 {
 namespace android
 {
+class AndroidFence;
 class AndroidDriverInterpreter;
 
 class MirNativeWindow : public ANativeWindow
@@ -40,7 +41,7 @@
     int query(int key, int* value) const;
     int perform(int key, va_list args );
     int dequeueBuffer(struct ANativeWindowBuffer** buffer);
-    int queueBuffer(struct ANativeWindowBuffer* buffer, int fence_fd);
+    int queueBuffer(struct ANativeWindowBuffer* buffer, std::shared_ptr<AndroidFence> const& fence);
 private:
 
     std::shared_ptr<AndroidDriverInterpreter> const driver_interpreter;

=== added file 'src/client/android/syncfence.cpp'
--- src/client/android/syncfence.cpp	1970-01-01 00:00:00 +0000
+++ src/client/android/syncfence.cpp	2013-03-14 15:40:25 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "syncfence.h"
+
+namespace mcla = mir::client::android;
+
+mcla::SyncFence::SyncFence(int fd, std::shared_ptr<IoctlWrapper> const& wrapper)
+ : ioctl_wrapper(wrapper),
+   fence_fd(fd)
+{
+}
+
+mcla::SyncFence::~SyncFence()
+{
+    if (fence_fd > 0)
+    {
+        ioctl_wrapper->close(fence_fd);
+    }
+}
+
+void mcla::SyncFence::wait()
+{
+    if (fence_fd > 0)
+    {
+        int timeout = -1;
+        ioctl_wrapper->ioctl(fence_fd, SYNC_IOC_WAIT, &timeout);
+    }
+}

=== added file 'src/client/android/syncfence.h'
--- src/client/android/syncfence.h	1970-01-01 00:00:00 +0000
+++ src/client/android/syncfence.h	2013-03-14 15:40:25 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+#ifndef MIR_CLIENT_ANDROID_SYNCFENCE_H_
+#define MIR_CLIENT_ANDROID_SYNCFENCE_H_
+
+#include <memory>
+
+#define SYNC_IOC_WAIT 0x40043E00
+
+namespace mir
+{
+namespace client
+{
+namespace android
+{
+
+class IoctlWrapper
+{
+public:
+    virtual ~IoctlWrapper() {}
+    virtual int ioctl(int fd, unsigned long int request, int* timeout) const = 0;
+    virtual int close(int fd) const = 0;
+
+protected:
+    IoctlWrapper() = default;
+    IoctlWrapper(IoctlWrapper const&) = delete;
+    IoctlWrapper& operator=(IoctlWrapper const&) = delete;
+};
+
+class AndroidFence
+{
+public:
+    virtual ~AndroidFence() {}
+    virtual void wait() = 0;
+
+protected:
+    AndroidFence() = default;
+    AndroidFence(AndroidFence const&) = delete;
+    AndroidFence& operator=(AndroidFence const&) = delete;
+};
+
+class SyncFence : public AndroidFence
+{
+public:
+    SyncFence(int fd, std::shared_ptr<IoctlWrapper> const& wrapper);
+    ~SyncFence();
+
+    void wait();
+
+private:
+    SyncFence(SyncFence const&) = delete;
+    SyncFence& operator=(SyncFence const&) = delete;
+
+    std::shared_ptr<IoctlWrapper> const ioctl_wrapper;
+    int const fence_fd;
+};
+
+}
+}
+}
+#endif /* MIR_CLIENT_ANDROID_SYNCFENCE_H_ */

=== modified file 'tests/unit-tests/client/CMakeLists.txt'
--- tests/unit-tests/client/CMakeLists.txt	2013-03-12 16:43:03 +0000
+++ tests/unit-tests/client/CMakeLists.txt	2013-03-14 15:40:25 +0000
@@ -14,6 +14,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_client_depository.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_client_platform.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_client_surface_interpreter.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_syncfence.cpp
 )
 endif()
 

=== modified file 'tests/unit-tests/client/test_android_native_window.cpp'
--- tests/unit-tests/client/test_android_native_window.cpp	2013-03-12 16:43:03 +0000
+++ tests/unit-tests/client/test_android_native_window.cpp	2013-03-14 15:40:25 +0000
@@ -19,6 +19,7 @@
 #include "src/client/mir_client_surface.h"
 #include "src/client/android/mir_native_window.h"
 #include "src/client/android/android_driver_interpreter.h"
+#include "src/client/android/syncfence.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -27,11 +28,17 @@
 
 namespace
 {
+
+struct MockSyncFence : public mcla::AndroidFence
+{
+    MOCK_METHOD0(wait, void());
+};
+
 class MockAndroidDriverInterpreter : public mcla::AndroidDriverInterpreter
 {
 public:
     MOCK_METHOD0(driver_requests_buffer, ANativeWindowBuffer*());
-    MOCK_METHOD2(driver_returns_buffer, void(ANativeWindowBuffer*, int));
+    MOCK_METHOD1(driver_returns_buffer, void(ANativeWindowBuffer*));
     MOCK_METHOD1(dispatch_driver_request_format, void(int));
     MOCK_CONST_METHOD1(driver_requests_info, int(int));
 };
@@ -166,13 +173,30 @@
     window->queueBuffer(window.get(), tmp, -1);
 }
 
-TEST_F(AndroidNativeWindowTest, native_window_queue_passes_buffer_and_fence_back)
+TEST_F(AndroidNativeWindowTest, native_window_queue_waits_for_sync_before_returning_buffer)
+{
+    using namespace testing;
+    ANativeWindowBuffer* tmp = nullptr;
+    auto window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    auto mock_fence = std::make_shared<testing::NiceMock<MockSyncFence>>();
+
+    InSequence s;
+    EXPECT_CALL(*mock_fence, wait())
+        .Times(1);
+    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(_))
+        .Times(1);
+    
+    window->queueBuffer(tmp, mock_fence);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_queue_passes_buffer_back)
 {
     ANativeWindowBuffer buffer;
     int fence_fd = 33;
     std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
 
-    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(&buffer, fence_fd))
+    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(&buffer))
         .Times(1);
 
     window->queueBuffer(window.get(), &buffer, fence_fd);
@@ -187,12 +211,12 @@
     window->queueBuffer_DEPRECATED(window.get(), tmp);
 }
 
-TEST_F(AndroidNativeWindowTest, native_window_queue_deprecated_always_indicates_no_wait)
+TEST_F(AndroidNativeWindowTest, native_window_queue_deprecated_passes_buffer_back)
 {
     ANativeWindowBuffer buffer;
     std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
 
-    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(&buffer, -1))
+    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(&buffer))
         .Times(1);
 
     window->queueBuffer_DEPRECATED(window.get(), &buffer);

=== added file 'tests/unit-tests/client/test_android_syncfence.cpp'
--- tests/unit-tests/client/test_android_syncfence.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/client/test_android_syncfence.cpp	2013-03-14 15:40:25 +0000
@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "src/client/android/syncfence.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace mcla = mir::client::android;
+
+namespace
+{
+class MockIoctlWrapper : public mcla::IoctlWrapper
+{
+public:
+    MOCK_CONST_METHOD3(ioctl, int(int, unsigned long int, int*));
+    MOCK_CONST_METHOD1(close, int(int));
+};
+}
+
+class SyncFenceTest : public ::testing::Test
+{
+public:
+    SyncFenceTest()
+     : ioctl_mock(std::make_shared<testing::NiceMock<MockIoctlWrapper>>()),
+       dummyfd(44), invalid_fd(-1)
+    {
+    }
+
+    std::shared_ptr<MockIoctlWrapper> const ioctl_mock;
+    int const dummyfd;
+    int const invalid_fd;
+};
+
+TEST_F(SyncFenceTest, test_valid_fd_wait)
+{
+    using namespace testing;
+
+    int timeout_val;
+    mcla::SyncFence fence(dummyfd, ioctl_mock);
+    EXPECT_CALL(*ioctl_mock, ioctl(dummyfd, SYNC_IOC_WAIT, _))
+        .Times(1)
+        .WillOnce(DoAll(SaveArgPointee<2>(&timeout_val),
+                        Return(0)));
+
+    fence.wait();
+    EXPECT_GT(0, timeout_val);
+}
+
+TEST_F(SyncFenceTest, test_valid_fd_destruction_closes_fd)
+{
+    EXPECT_CALL(*ioctl_mock, close(dummyfd))
+        .Times(1);
+
+    mcla::SyncFence fence(dummyfd, ioctl_mock);
+}
+
+TEST_F(SyncFenceTest, test_invalid_fd_does_not_call_ioctl_on_wait)
+{
+    using namespace testing;
+
+    mcla::SyncFence fence(invalid_fd, ioctl_mock);
+    EXPECT_CALL(*ioctl_mock, ioctl(_, _, _))
+        .Times(0);
+
+    fence.wait();
+}
+
+TEST_F(SyncFenceTest, test_invalid_fd_destruction_does_not_close_fd)
+{
+    using namespace testing;
+    EXPECT_CALL(*ioctl_mock, close(_))
+        .Times(0);
+
+    mcla::SyncFence fence(invalid_fd, ioctl_mock);
+}

=== modified file 'tests/unit-tests/client/test_client_surface_interpreter.cpp'
--- tests/unit-tests/client/test_client_surface_interpreter.cpp	2013-03-12 15:27:46 +0000
+++ tests/unit-tests/client/test_client_surface_interpreter.cpp	2013-03-14 15:40:25 +0000
@@ -125,7 +125,6 @@
 {
     using namespace testing;
     ANativeWindowBuffer buffer;
-    int fence_fd = -1;
 
     MockMirSurface mock_surface{surf_params};
     mcla::ClientSurfaceInterpreter interpreter(mock_surface);
@@ -133,7 +132,7 @@
     EXPECT_CALL(mock_surface, next_buffer(_,_))
         .Times(1);
 
-    interpreter.driver_returns_buffer(&buffer, fence_fd);
+    interpreter.driver_returns_buffer(&buffer);
 }
 
 /* format is an int that is set by the driver. these are not the HAL_PIXEL_FORMATS in android */