diff --git a/android-rebuild.sh b/android-rebuild.sh
index 900a2ce..e01fd44 100755
--- a/android-rebuild.sh
+++ b/android-rebuild.sh
@@ -229,6 +229,7 @@
         for UNIT_TEST in android_emu_unittests emugl_common_host_unittests \
                          emulator_libui_unittests \
                          emulator_crashreport_unittests \
+                         libOpenglRender_unittests \
                          libGLcommon_unittests; do
             for TEST in $OUT_DIR/$UNIT_TEST$EXE_SUFFIX; do
                 echo "   - ${TEST#$OUT_DIR/}"
@@ -242,6 +243,7 @@
         for UNIT_TEST in android_emu64_unittests emugl64_common_host_unittests \
                          emulator64_libui_unittests \
                          emulator64_crashreport_unittests \
+                         lib64OpenglRender_unittests \
                          lib64GLcommon_unittests; do
              for TEST in $OUT_DIR/$UNIT_TEST$EXE_SUFFIX; do
                  echo "   - ${TEST#$OUT_DIR/}"
diff --git a/android/opengl/OpenglEsPipe.cpp b/android/opengl/OpenglEsPipe.cpp
index 35aafff..9e0491c 100644
--- a/android/opengl/OpenglEsPipe.cpp
+++ b/android/opengl/OpenglEsPipe.cpp
@@ -22,7 +22,7 @@
 #include <string.h>
 
 // Set to 1 or 2 for debug traces
-//#define DEBUG 1
+#define DEBUG 0
 
 #if DEBUG >= 1
 #define D(...) printf(__VA_ARGS__), printf("\n"), fflush(stdout)
@@ -36,10 +36,11 @@
 #define DD(...) ((void)0)
 #endif
 
-using emugl::ChannelBuffer;
+using ChannelBuffer = emugl::RenderChannel::Buffer;
 using emugl::RenderChannel;
 using emugl::RenderChannelPtr;
 using ChannelState = emugl::RenderChannel::State;
+using IoResult = emugl::RenderChannel::IoResult;
 
 namespace android {
 namespace opengl {
@@ -79,8 +80,7 @@
     /////////////////////////////////////////////////////////////////////////
     // Constructor, check that |mIsWorking| is true after this call to verify
     // that everything went well.
-    EmuglPipe(void* hwPipe,
-              Service* service,
+    EmuglPipe(void* hwPipe, Service* service,
               const emugl::RendererPtr& renderer)
         : AndroidPipe(hwPipe, service) {
         mChannel = renderer->createRenderChannel();
@@ -90,10 +90,10 @@
         }
 
         mIsWorking = true;
-        mChannel->setEventCallback([this](ChannelState state,
-                                          RenderChannel::EventSource source) {
-            this->onChannelIoEvent(state);
-        });
+        mChannel->setEventCallback(
+                [this](RenderChannel::State events) {
+                    this->onChannelHostEvent(events);
+                });
     }
 
     //////////////////////////////////////////////////////////////////////////
@@ -103,20 +103,27 @@
         D("%s", __func__);
         mIsWorking = false;
         mChannel->stop();
-        // stop callback will call close() which deletes the pipe
+        delete this;
     }
 
     virtual unsigned onGuestPoll() const override {
         DD("%s", __func__);
 
         unsigned ret = 0;
-        ChannelState state = mChannel->currentState();
-        if (canReadAny(state)) {
+        if (mDataForReadingLeft > 0) {
             ret |= PIPE_POLL_IN;
         }
-        if (canWrite(state)) {
+        ChannelState state = mChannel->state();
+        if ((state & ChannelState::CanRead) != 0) {
+            ret |= PIPE_POLL_IN;
+        }
+        if ((state & ChannelState::CanWrite) != 0) {
             ret |= PIPE_POLL_OUT;
         }
+        if ((state & ChannelState::Stopped) != 0) {
+            ret |= PIPE_POLL_HUP;
+        }
+        DD("%s: returning %d", __func__, ret);
         return ret;
     }
 
@@ -124,8 +131,8 @@
             override {
         DD("%s", __func__);
 
-        // Consume the pipe's dataForReading, then put the next received data piece
-        // there. Repeat until the buffers are full or we're out of data
+        // Consume the pipe's dataForReading, then put the next received data
+        // piece there. Repeat until the buffers are full or we're out of data
         // in the channel.
         int len = 0;
         size_t buffOffset = 0;
@@ -135,29 +142,37 @@
         while (buff != buffEnd) {
             if (mDataForReadingLeft == 0) {
                 // No data left, read a new chunk from the channel.
-                //
-                // Spin a little bit here: many GL calls are much faster than
-                // the whole host-to-guest-to-host transition.
                 int spinCount = 20;
-                while (!mChannel->read(&mDataForReading,
-                                    RenderChannel::CallType::Nonblocking)) {
-                    if (mChannel->isStopped()) {
-                        return PIPE_ERROR_IO;
-                    } else if (len == 0) {
-                        if (canRead(mChannel->currentState()) || --spinCount > 0) {
-                            continue;
-                        }
-                        return PIPE_ERROR_AGAIN;
-                    } else {
+                for (;;) {
+                    auto result = mChannel->tryRead(&mDataForReading);
+                    if (result == IoResult::Ok) {
+                        mDataForReadingLeft = mDataForReading.size();
+                        break;
+                    }
+                    DD("%s: tryRead() failed with %d", __func__, (int)result);
+                    // This failed either because the channel was stopped
+                    // from the host, or if there was no data yet in the
+                    // channel.
+                    if (len > 0) {
+                        DD("%s: returning %d bytes", __func__, (int)len);
                         return len;
                     }
+                    if (result == IoResult::Error) {
+                        return PIPE_ERROR_IO;
+                    }
+                    // Spin a little before declaring there is nothing
+                    // to read. Many GL calls are much faster than the
+                    // whole host-to-guest-to-host transition.
+                    if (--spinCount > 0) {
+                        continue;
+                    }
+                    DD("%s: returning PIPE_ERROR_AGAIN", __func__);
+                    return PIPE_ERROR_AGAIN;
                 }
-
-                mDataForReadingLeft = mDataForReading.size();
             }
 
             const size_t curSize =
-                    std::min(buff->size - buffOffset, mDataForReadingLeft.load());
+                    std::min(buff->size - buffOffset, mDataForReadingLeft);
             memcpy(buff->data + buffOffset,
                 mDataForReading.data() +
                         (mDataForReading.size() - mDataForReadingLeft),
@@ -172,6 +187,7 @@
             }
         }
 
+        DD("%s: received %d bytes", __func__, (int)len);
         return len;
     }
 
@@ -179,8 +195,9 @@
                             int numBuffers) override {
         DD("%s", __func__);
 
-        if (int ret = sendReadyStatus()) {
-            return ret;
+        if (!mIsWorking) {
+            DD("%s: pipe already closed!", __func__);
+            return PIPE_ERROR_IO;
         }
 
         // Count the total bytes to send.
@@ -198,9 +215,12 @@
             ptr += buffers[n].size;
         }
 
+        D("%s: sending %d bytes to host", __func__, count);
         // Send it through the channel.
-        if (!mChannel->write(std::move(outBuffer))) {
-            return PIPE_ERROR_IO;
+        auto result = mChannel->tryWrite(std::move(outBuffer));
+        if (result != IoResult::Ok) {
+            D("%s: tryWrite() failed with %d", __func__, (int)result);
+            return result == IoResult::Error ? PIPE_ERROR_IO : PIPE_ERROR_AGAIN;
         }
 
         return count;
@@ -209,112 +229,66 @@
     virtual void onGuestWantWakeOn(int flags) override {
         DD("%s: flags=%d", __func__, flags);
 
-        // We reset these flags when we actually wake the pipe, so only
-        // add to them here.
-        mCareAboutRead |= (flags & PIPE_WAKE_READ) != 0;
-        mCareAboutWrite |= (flags & PIPE_WAKE_WRITE) != 0;
+        // Translate |flags| into ChannelState flags.
+        ChannelState wanted = ChannelState::Empty;
+        if (flags & PIPE_WAKE_READ) {
+            wanted |= ChannelState::CanRead;
+        }
+        if (flags & PIPE_WAKE_WRITE) {
+            wanted |= ChannelState::CanWrite;
+        }
 
-        ChannelState state = mChannel->currentState();
-        processIoEvents(state);
+        // Signal events that are already available now.
+        ChannelState state = mChannel->state();
+        ChannelState available = state & wanted;
+        DD("%s: state=%d wanted=%d available=%d", __func__, (int)state,
+           (int)wanted, (int)available);
+        if (available != ChannelState::Empty) {
+            DD("%s: signaling events %d", __func__, (int)available);
+            signalState(available);
+            wanted &= ~available;
+        }
+
+        // Ask the channel to be notified of remaining events.
+        if (wanted != ChannelState::Empty) {
+            DD("%s: waiting for events %d", __func__, (int)wanted);
+            mChannel->setWantedEvents(wanted);
+        }
     }
 
 private:
-    // Returns true iff there is data to read from the emugl channel.
-    static bool canRead(ChannelState state) {
-        return (state & ChannelState::CanRead) != ChannelState::Empty;
-    }
-
-    // Returns true iff the emugl channel can accept data.
-    static bool canWrite(ChannelState state) {
-        return (state & ChannelState::CanWrite) != ChannelState::Empty;
-    }
-
-    // Returns true iff there is data to read from the local cache or from
-    // the emugl channel.
-    bool canReadAny(ChannelState state) const {
-        return mDataForReadingLeft != 0 || canRead(state);
-    }
-
-    // Check that the pipe is working and that the render channel can be
-    // written to. Return 0 in case of success, and one PIPE_ERROR_XXX
-    // value on error.
-    int sendReadyStatus() const {
-        if (mIsWorking) {
-            ChannelState state = mChannel->currentState();
-            if (canWrite(state)) {
-                return 0;
-            }
-            return PIPE_ERROR_AGAIN;
-        } else if (!mHwPipe) {
-            return PIPE_ERROR_IO;
-        } else {
-            return PIPE_ERROR_INVAL;
-        }
-    }
-
-    // Check the read/write state of the render channel and signal the pipe
-    // if any condition meets mCareAboutRead or mCareAboutWrite.
-    void processIoEvents(ChannelState state) {
+    // Called to signal the guest that read/write wake events occured.
+    // Note: this can be called from either the guest or host render
+    // thread.
+    void signalState(ChannelState state) {
         int wakeFlags = 0;
-
-        if (mCareAboutRead && canReadAny(state)) {
+        if ((state & ChannelState::CanRead) != 0) {
             wakeFlags |= PIPE_WAKE_READ;
-            mCareAboutRead = false;
         }
-        if (mCareAboutWrite && canWrite(state)) {
+        if ((state & ChannelState::CanWrite) != 0) {
             wakeFlags |= PIPE_WAKE_WRITE;
-            mCareAboutWrite = false;
         }
-
-        // Send wake signal to the guest if needed.
         if (wakeFlags != 0) {
-            signalWake(wakeFlags);
+            this->signalWake(wakeFlags);
         }
     }
 
     // Called when an i/o event occurs on the render channel
-    void onChannelIoEvent(ChannelState state) {
-        D("%s: %d", __func__, (int)state);
-
-        if ((state & ChannelState::Stopped) != ChannelState::Empty) {
-            close();
-        } else {
-            processIoEvents(state);
-        }
-    }
-
-    // Close the pipe, this may be called from the host or guest side.
-    void close() {
-        D("%s", __func__);
-
-        // If the pipe isn't in a working state, delete immediately.
-        if (!mIsWorking) {
-            mChannel->stop();
-            delete this;
+    void onChannelHostEvent(ChannelState state) {
+        D("%s: events %d", __func__, (int)state);
+        // NOTE: This is called from the host-side render thread.
+        // but closeFromHost() and signalWake() can be called from
+        // any thread.
+        if ((state & ChannelState::Stopped) != 0) {
+            this->closeFromHost();
             return;
         }
-
-        // Force the closure of the channel - if a guest is blocked
-        // waiting for a wake signal, it will receive an error.
-        if (mHwPipe) {
-            closeFromHost();
-            mHwPipe = nullptr;
-        }
-
-        mIsWorking = false;
+        signalState(state);
     }
 
     // A RenderChannel pointer used for communication.
     RenderChannelPtr mChannel;
 
-    // Guest state tracking - if it requested us to wake on read/write
-    // availability. If guest doesn't care about some operation type, we should
-    // not wake it when that operation becomes available.
-    // Note: we need an atomic or operation, and atomic<bool> doesn't have it -
-    //  that's why it is atomic<char> here.
-    std::atomic<char> mCareAboutRead {false};
-    std::atomic<char> mCareAboutWrite {false};
-
     // Set to |true| if the pipe is in working state, |false| means we're not
     // initialized or the pipe is closed.
     bool mIsWorking = false;
@@ -326,7 +300,7 @@
     // If guest didn't have enough room for the whole buffer, we track the
     // number of remaining bytes in |mDataForReadingLeft| for the next read().
     ChannelBuffer mDataForReading;
-    std::atomic<size_t> mDataForReadingLeft { 0 };
+    size_t mDataForReadingLeft = 0;
 
     DISALLOW_COPY_ASSIGN_AND_MOVE(EmuglPipe);
 };
diff --git a/distrib/android-emugl/DESIGN b/distrib/android-emugl/DESIGN
index 943a0e4..ceb8331 100644
--- a/distrib/android-emugl/DESIGN
+++ b/distrib/android-emugl/DESIGN
@@ -301,7 +301,7 @@
 
 The "IOStream" is a very simple abstract class used to send byte messages
 both in the guest and host. It is defined through a shared header under
-$EMUGL/host/include/libOpenglRender/IOStream.h
+$EMUGL/host/include/OpenglRender/IOStream.h
 
 Note that despite the path, this header is included by *both* host and guest
 source code. The main idea around IOStream's design is that to send a message,
diff --git a/distrib/android-emugl/host/include/libOpenglRender/IOStream.h b/distrib/android-emugl/host/include/OpenglRender/IOStream.h
similarity index 94%
rename from distrib/android-emugl/host/include/libOpenglRender/IOStream.h
rename to distrib/android-emugl/host/include/OpenglRender/IOStream.h
index a0df579..46b8c6a 100644
--- a/distrib/android-emugl/host/include/libOpenglRender/IOStream.h
+++ b/distrib/android-emugl/host/include/OpenglRender/IOStream.h
@@ -33,7 +33,7 @@
 
 public:
     size_t read(void* buf, size_t bufLen) {
-        if (!read(buf, &bufLen)) {
+        if (!readRaw(buf, &bufLen)) {
             return 0;
         }
         return bufLen;
@@ -75,7 +75,7 @@
 protected:
     virtual void *allocBuffer(size_t minSize) = 0;
     virtual int commitBuffer(size_t size) = 0;
-    virtual const unsigned char *read(void *buf, size_t *inout_len) = 0;
+    virtual const unsigned char *readRaw(void *buf, size_t *inout_len) = 0;
 
 private:
     unsigned char* m_buf = nullptr;
diff --git a/distrib/android-emugl/host/include/OpenglRender/RenderChannel.h b/distrib/android-emugl/host/include/OpenglRender/RenderChannel.h
index 6c139c3..40232e2 100644
--- a/distrib/android-emugl/host/include/OpenglRender/RenderChannel.h
+++ b/distrib/android-emugl/host/include/OpenglRender/RenderChannel.h
@@ -21,18 +21,35 @@
 
 namespace emugl {
 
-// Turn the RenderChannel::Event enum into flags.
+// Turn the RenderChannel::State enum into flags.
 using namespace ::android::base::EnumFlags;
 
-// A type used for data passing.
-using ChannelBuffer = android::base::SmallFixedVector<char, 512>;
-
-// RenderChannel - an interface for a single guest to host renderer connection.
-// It allows the guest to send GPU emulation protocol-serialized messages to an
-// asynchronous renderer, read the responses and subscribe for state updates.
+// RenderChannel - For each guest-to-host renderer connection, this provides
+// an interface for the guest side to interact with the corresponding renderer
+// thread on the host. Its main purpose is to send and receive wire protocol
+// bytes in an asynchronous way (compatible with Android pipes).
+//
+// Usage is the following:
+//    1) Get an instance pointer through a dedicated Renderer function
+//       (e.g. RendererImpl::createRenderChannel()).
+//
+//    2) Call setEventCallback() to indicate which callback should be called
+//       when the channel's state has changed due to a host thread event.
+//
 class RenderChannel {
 public:
-    // Flags for the channel state.
+    // A type used to pass byte packets between the guest and the
+    // RenderChannel instance. Experience has shown that using a
+    // SmallFixedVector<char, N> instance instead of a std::vector<char>
+    // avoids a lot of un-necessary heap allocations. The current size
+    // of 512 was selected after profiling existing traffic, including
+    // the one used in protocol-heavy benchmark like Antutu3D.
+    using Buffer = android::base::SmallFixedVector<char, 512>;
+
+    // Bit-flags for the channel state.
+    // |CanRead| means there is data from the host to read.
+    // |CanWrite| means there is room to send data to the host.
+    // |Stopped| means the channel was stopped.
     enum class State {
         // Can't use None here, some system header declares it as a macro.
         Empty = 0,
@@ -41,47 +58,60 @@
         Stopped = 1 << 2,
     };
 
-    // Possible points of origin for an event in EventCallback.
-    enum class EventSource {
-        RenderChannel,
-        Client,
+    // Values corresponding to the result of i/o operations.
+    // |Ok| means everything went well.
+    // |TryAgain| means the operation could not be performed and should be
+    // tried later.
+    // |Error| means an error happened (i.e. the channel is stopped).
+    enum class IoResult {
+        Ok = 0,
+        TryAgain = 1,
+        Error = 2,
     };
 
-    // Types of read() the channel supports.
-    enum class CallType {
-        Blocking,    // if the call can't do what it needs, block until it can
-        Nonblocking, // immidiately return if the call can't do the job
-    };
+    // Type of a callback used to tell the guest when the RenderChannel
+    // state changes. Used by setEventCallback(). The parameter contains
+    // the State bits matching the event, i.e. it is the logical AND of
+    // the last value passed to setWantedEvents() and the current
+    // RenderChannel state.
+    using EventCallback = std::function<void(State)>;
 
-    // Sets a single (!) callback that is called if some event happends that
-    // changes the channel state - e.g. when it's stopped, or it gets some data
-    // the client can read after being empty, or it isn't full anymore and the
-    // client may write again without blocking.
-    // If the state isn't State::Empty, the |callback| is called for the first
-    // time during the setEventCallback() to report this initial state.
-    using EventCallback = std::function<void(State, EventSource)>;
-    virtual void setEventCallback(EventCallback callback) = 0;
+    // Sets a single (!) callback that is called when the channel state's
+    // changes due to an event *from* *the* *host* only. |callback| is a
+    // guest-provided callback that will be called from the host renderer
+    // thread, not the guest one.
+    virtual void setEventCallback(EventCallback&& callback) = 0;
 
-    // Writes the data in |buffer| into the channel. |buffer| is moved from.
-    // Blocks if there's no room in the channel (shouldn't really happen).
-    // Returns false if the channel is stopped.
-    virtual bool write(ChannelBuffer&& buffer) = 0;
-    // Reads a chunk of data from the channel. Returns false if there was no
-    // data for a non-blocking call or if the channel is stopped.
-    virtual bool read(ChannelBuffer* buffer, CallType callType) = 0;
+    // Used to indicate which i/o events the guest wants to be notified
+    // through its StateChangeCallback. |state| must be a combination of
+    // State::CanRead or State::CanWrite only. This will *not* call the
+    // callback directly since this happens in the guest thread.
+    virtual void setWantedEvents(State state) = 0;
 
     // Get the current state flags.
-    virtual State currentState() const = 0;
+    virtual State state() const = 0;
+
+    // Try to writes the data in |buffer| into the channel. On success,
+    // return IoResult::Ok and moves |buffer|. On failure, return
+    // IoResult::TryAgain if the channel was full, or IoResult::Error
+    // if it is stopped.
+    virtual IoResult tryWrite(Buffer&& buffer) = 0;
+
+    // Try to read data from the channel. On success, return IoResult::Ok and
+    // sets |*buffer| to contain the data. On failure, return
+    // IoResult::TryAgain if the channel was empty, or IoResult::Error if
+    // it was stopped.
+    virtual IoResult tryRead(Buffer* buffer) = 0;
 
     // Abort all pending operations. Any following operation is a noop.
+    // Once a channel is stopped, it cannot be re-started.
     virtual void stop() = 0;
-    // Check if the channel is stopped.
-    virtual bool isStopped() const = 0;
 
 protected:
     ~RenderChannel() = default;
 };
 
+// Shared pointer to RenderChannel instance.
 using RenderChannelPtr = std::shared_ptr<RenderChannel>;
 
 }  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/Android.mk b/distrib/android-emugl/host/libs/libOpenglRender/Android.mk
index f165400..ca1a857 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/Android.mk
+++ b/distrib/android-emugl/host/libs/libOpenglRender/Android.mk
@@ -63,3 +63,13 @@
 $(call emugl-export,CFLAGS,$(EMUGL_USER_CFLAGS))
 
 $(call emugl-end-module)
+
+### OpenglRender unittests
+$(call emugl-begin-executable,lib$(BUILD_TARGET_SUFFIX)OpenglRender_unittests)
+
+LOCAL_SRC_FILES := \
+    BufferQueue_unittest.cpp \
+
+$(call emugl-import,lib$(BUILD_TARGET_SUFFIX)OpenglRender libemugl_gtest)
+$(call local-link-static-c++lib)
+$(call emugl-end-module)
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/BufferQueue.h b/distrib/android-emugl/host/libs/libOpenglRender/BufferQueue.h
new file mode 100644
index 0000000..3a00a4b
--- /dev/null
+++ b/distrib/android-emugl/host/libs/libOpenglRender/BufferQueue.h
@@ -0,0 +1,164 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include "OpenglRender/RenderChannel.h"
+#include "android/base/Compiler.h"
+#include "android/base/synchronization/Lock.h"
+#include "android/base/synchronization/MessageChannel.h"
+
+#include <memory>
+
+#include <stddef.h>
+
+namespace emugl {
+
+// BufferQueue models a FIFO queue of RenderChannel::Buffer instances
+// that can be used between two different threads. Note that it depends,
+// for synchronization, on an external lock (passed as a reference in
+// the BufferQueue constructor).
+//
+// This allows one to use multiple BufferQueue instances whose content
+// are protected by a single lock.
+class BufferQueue {
+    using ConditionVariable = android::base::ConditionVariable;
+    using Lock = android::base::Lock;
+    using AutoLock = android::base::AutoLock;
+
+public:
+    using IoResult = RenderChannel::IoResult;
+    using Buffer = RenderChannel::Buffer;
+
+    // Constructor. |capacity| is the maximum number of Buffer instances in
+    // the queue, and |lock| is a reference to an external lock provided by
+    // the caller.
+    BufferQueue(size_t capacity, android::base::Lock& lock)
+        : mCapacity(capacity), mBuffers(new Buffer[capacity]), mLock(lock) {}
+
+    // Return true iff the queue has been closed. Remaining items can
+    // be read from its, but it won't be possible to add new items to it.
+    // bool closed() const { return mClosed; }
+
+    // Return true iff one can send a buffer to the queue, i.e. if it
+    // is not full.
+    bool canPushLocked() const { return !mClosed && (mCount < mCapacity); }
+
+    // Return true iff one can receive a buffer from the queue, i.e. if
+    // it is not empty.
+    bool canPopLocked() const { return mCount > 0U; }
+
+    // Return true iff the queue is closed.
+    bool isClosedLocked() const { return mClosed; }
+
+    // Try to send a buffer to the queue. On success, return IoResult::Ok
+    // and moves |buffer| to the queue. On failure, return
+    // IoResult::TryAgain if the queue was full, or IoResult::Error
+    // if it was closed.
+    IoResult tryPushLocked(Buffer&& buffer) {
+        if (mClosed) {
+            return IoResult::Error;
+        }
+        if (mCount >= mCapacity) {
+            return IoResult::TryAgain;
+        }
+        size_t pos = mPos + mCount;
+        if (pos >= mCapacity) {
+            pos -= mCapacity;
+        }
+        mBuffers[pos] = std::move(buffer);
+        if (mCount++ == 0) {
+            mCanPop.signal();
+        }
+        return IoResult::Ok;
+    }
+
+    // Push a buffer to the queue. This is a blocking call. On success,
+    // move |buffer| into the queue and return IoResult::Ok. On failure,
+    // return IoResult::Error meaning the queue was closed.
+    IoResult pushLocked(Buffer&& buffer) {
+        while (mCount == mCapacity) {
+            if (mClosed) {
+                return IoResult::Error;
+            }
+            mCanPush.wait(&mLock);
+        }
+        return tryPushLocked(std::move(buffer));
+    }
+
+    // Try to read a buffer from the queue. On success, moves item into
+    // |*buffer| and return IoResult::Ok. On failure, return IoResult::Error
+    // if the queue is empty and closed, and IoResult::TryAgain if it is
+    // empty but not close.
+    IoResult tryPopLocked(Buffer* buffer) {
+        if (mCount == 0) {
+            return mClosed ? IoResult::Error : IoResult::TryAgain;
+        }
+        *buffer = std::move(mBuffers[mPos]);
+        size_t pos = mPos + 1;
+        if (pos >= mCapacity) {
+            pos -= mCapacity;
+        }
+        mPos = pos;
+        if (mCount-- == mCapacity) {
+            mCanPush.signal();
+        }
+        return IoResult::Ok;
+    }
+
+    // Pop a buffer from the queue. This is a blocking call. On success,
+    // move item into |*buffer| and return IoResult::Ok. On failure,
+    // return IoResult::Error to indicate the queue was closed.
+    IoResult popLocked(Buffer* buffer) {
+        while (mCount == 0) {
+            if (mClosed) {
+                // Closed queue is empty.
+                return IoResult::Error;
+            }
+            mCanPop.wait(&mLock);
+        }
+        return tryPopLocked(buffer);
+    }
+
+    // Close the queue, it is no longer possible to push new items
+    // to it (i.e. push() will always return IoResult::Error), or to
+    // read from an empty queue (i.e. pop() will always return
+    // IoResult::Error once the queue becomes empty).
+    void closeLocked() {
+        mClosed = true;
+
+        // Wake any potential waiters.
+        if (mCount == mCapacity) {
+            mCanPush.broadcast();
+        }
+        if (mCount == 0) {
+            mCanPop.broadcast();
+        }
+    }
+
+private:
+    size_t mCapacity = 0;
+    size_t mPos = 0;
+    size_t mCount = 0;
+    bool mClosed = false;
+    std::unique_ptr<Buffer[]> mBuffers;
+
+    Lock& mLock;
+    ConditionVariable mCanPush;
+    ConditionVariable mCanPop;
+
+    // This will force the same for SyncBufferQueue and RenderChannelImpl
+    DISALLOW_COPY_ASSIGN_AND_MOVE(BufferQueue);
+};
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/BufferQueue_unittest.cpp b/distrib/android-emugl/host/libs/libOpenglRender/BufferQueue_unittest.cpp
new file mode 100644
index 0000000..778a766
--- /dev/null
+++ b/distrib/android-emugl/host/libs/libOpenglRender/BufferQueue_unittest.cpp
@@ -0,0 +1,328 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "BufferQueue.h"
+
+#ifdef _WIN32
+#undef ERROR   // Make LOG(ERROR) compile properly.
+#endif
+
+#include "android/base/Log.h"
+#include "android/base/synchronization/Lock.h"
+#include "android/base/synchronization/MessageChannel.h"
+#include "android/base/threads/Thread.h"
+#include "OpenglRender/RenderChannel.h"
+
+#include <gtest/gtest.h>
+
+namespace emugl {
+
+using android::base::Lock;
+using android::base::AutoLock;
+using Buffer = BufferQueue::Buffer;
+using IoResult = BufferQueue::IoResult;
+
+TEST(BufferQueue, Constructor) {
+    Lock lock;
+    BufferQueue queue(16, lock);
+}
+
+TEST(BufferQueue, tryPushLocked) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    AutoLock al(lock);
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPushLocked(Buffer("Hello")));
+    EXPECT_EQ(IoResult::Ok, queue.tryPushLocked(Buffer("World")));
+
+    Buffer buff0("You Shall Not Move");
+    EXPECT_EQ(IoResult::TryAgain, queue.tryPushLocked(std::move(buff0)));
+    EXPECT_FALSE(buff0.empty()) << "Buffer should not be moved on failure!";
+}
+
+TEST(BufferQueue, tryPushLockedOnClosedQueue) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    AutoLock al(lock);
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPushLocked(Buffer("Hello")));
+
+    // Closing the queue prevents pushing new items to the queue.
+    queue.closeLocked();
+
+    EXPECT_EQ(IoResult::Error, queue.tryPushLocked(Buffer("World")));
+}
+
+TEST(BufferQueue, tryPopLocked) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    AutoLock al(lock);
+
+    Buffer buffer;
+    EXPECT_EQ(IoResult::TryAgain, queue.tryPopLocked(&buffer));
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPushLocked(Buffer("Hello")));
+    EXPECT_EQ(IoResult::Ok, queue.tryPushLocked(Buffer("World")));
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPopLocked(&buffer));
+    EXPECT_STREQ("Hello", buffer.data());
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPopLocked(&buffer));
+    EXPECT_STREQ("World", buffer.data());
+
+    EXPECT_EQ(IoResult::TryAgain, queue.tryPopLocked(&buffer));
+    EXPECT_STREQ("World", buffer.data());
+}
+
+TEST(BufferQueue, tryPopLockedOnClosedQueue) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    AutoLock al(lock);
+
+    Buffer buffer;
+    EXPECT_EQ(IoResult::TryAgain, queue.tryPopLocked(&buffer));
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPushLocked(Buffer("Hello")));
+    EXPECT_EQ(IoResult::Ok, queue.tryPushLocked(Buffer("World")));
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPopLocked(&buffer));
+    EXPECT_STREQ("Hello", buffer.data());
+
+    // Closing the queue doesn't prevent popping existing items, but
+    // will generate IoResult::Error once it is empty.
+    queue.closeLocked();
+
+    EXPECT_EQ(IoResult::Ok, queue.tryPopLocked(&buffer));
+    EXPECT_STREQ("World", buffer.data());
+
+    EXPECT_EQ(IoResult::Error, queue.tryPopLocked(&buffer));
+    EXPECT_STREQ("World", buffer.data());
+}
+
+namespace {
+
+// A TestThread instance that holds a reference to a queue and can either
+// push or pull to it, on command from another thread. This uses a
+// MessageChannel to implement the communication channel between the
+// command thread and this one.
+class TestThread final : public android::base::Thread {
+public:
+    TestThread(Lock& lock, BufferQueue& queue)
+        // NOTE: The default stack size of android::base::Thread is too
+        //       small and will result in runtime errors.
+        : mLock(lock), mQueue(queue) {}
+
+    // Tell the test thread to push |buffer| to the queue.
+    // Call endPush() later to get the command's result.
+    bool startPush(Buffer&& buffer) {
+        return mInput.send(
+                Request { .cmd = Cmd::Push, .buffer = std::move(buffer) });
+    }
+
+    // Get the result of a previous startPush() command.
+    IoResult endPush() {
+        Reply reply = {};
+        if (!mOutput.receive(&reply)) {
+            return IoResult::Error;
+        }
+        return reply.result;
+    }
+
+    // Tell the test thread to pop a buffer from the queue.
+    // Call endPop() to get the command's result, as well as the popped
+    // buffer if it is IoResult::Ok.
+    bool startPop() {
+        return mInput.send(Request { .cmd = Cmd::Pop });
+    }
+
+    // Return the result of a previous startPop() command. If result is
+    // IoResult::Ok, sets |*buffer| to the result buffer.
+    IoResult endPop(Buffer* buffer) {
+        Reply reply = {};
+        if (!mOutput.receive(&reply)) {
+            return IoResult::Error;
+        }
+        if (reply.result == IoResult::Ok) {
+            *buffer = std::move(reply.buffer);
+        }
+        return reply.result;
+    }
+
+    // Tell the test thread to close the queue from its side.
+    void doClose() {
+        mInput.send(Request { .cmd = Cmd::Close });
+    }
+
+    // Tell the test thread to stop after completing its current command.
+    void stop() {
+        mInput.send(Request { .cmd = Cmd::Stop });
+        ASSERT_TRUE(this->wait());
+    }
+
+private:
+    enum class Cmd {
+        Push,
+        Pop,
+        Close,
+        Stop,
+    };
+
+    struct Request {
+        Cmd cmd;
+        Buffer buffer;
+    };
+
+    struct Reply {
+        IoResult result;
+        Buffer buffer;
+    };
+
+    // Main thread function.
+    virtual intptr_t main() override final {
+        for (;;) {
+            Request r;
+            if (!mInput.receive(&r)) {
+                LOG(ERROR) << "Could not receive command";
+                break;
+            }
+            if (r.cmd == Cmd::Stop) {
+                break;
+            }
+            mLock.lock();
+            Reply reply = {};
+            bool sendReply = false;
+            switch (r.cmd) {
+                case Cmd::Push:
+                    reply.result = mQueue.pushLocked(std::move(r.buffer));
+                    sendReply = true;
+                    break;
+
+                case Cmd::Pop:
+                    reply.result = mQueue.popLocked(&reply.buffer);
+                    sendReply = true;
+                    break;
+
+                case Cmd::Close:
+                    mQueue.closeLocked();
+                    break;
+
+                default:
+                    ;
+            }
+            mLock.unlock();
+            if (sendReply) {
+                if (!mOutput.send(std::move(reply))) {
+                    LOG(ERROR) << "Could not send reply";
+                    break;
+                }
+            }
+        }
+        return 0U;
+    }
+
+    Lock& mLock;
+    BufferQueue& mQueue;
+    android::base::MessageChannel<Request, 4> mInput;
+    android::base::MessageChannel<Reply, 4> mOutput;
+};
+
+}  // namespace
+
+TEST(BufferQueue, pushLocked) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    TestThread thread(lock, queue);
+
+    ASSERT_TRUE(thread.start());
+    ASSERT_TRUE(thread.startPop());
+
+    lock.lock();
+    EXPECT_EQ(IoResult::Ok, queue.pushLocked(Buffer("Hello")));
+    EXPECT_EQ(IoResult::Ok, queue.pushLocked(Buffer("World")));
+    EXPECT_EQ(IoResult::Ok, queue.pushLocked(Buffer("Foo")));
+    lock.unlock();
+
+    thread.stop();
+}
+
+TEST(BufferQueue, pushLockedWithClosedQueue) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    TestThread thread(lock, queue);
+
+    ASSERT_TRUE(thread.start());
+
+    lock.lock();
+    EXPECT_EQ(IoResult::Ok, queue.pushLocked(Buffer("Hello")));
+    // Closing the queue prevents pushing new items, but not
+    // pulling from the queue.
+    queue.closeLocked();
+    EXPECT_EQ(IoResult::Error, queue.pushLocked(Buffer("World")));
+    lock.unlock();
+
+    Buffer buffer;
+    ASSERT_TRUE(thread.startPop());
+    EXPECT_EQ(IoResult::Ok, thread.endPop(&buffer));
+    EXPECT_STREQ("Hello", buffer.data());
+
+    thread.stop();
+}
+
+TEST(BufferQueue, popLocked) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    TestThread thread(lock, queue);
+
+    ASSERT_TRUE(thread.start());
+    ASSERT_TRUE(thread.startPush(Buffer("Hello World")));
+    EXPECT_EQ(IoResult::Ok, thread.endPush());
+
+    lock.lock();
+    Buffer buffer;
+    EXPECT_EQ(IoResult::Ok, queue.popLocked(&buffer));
+    EXPECT_STREQ("Hello World", buffer.data());
+    lock.unlock();
+
+    thread.stop();
+}
+
+TEST(BufferQueue, popLockedWithClosedQueue) {
+    Lock lock;
+    BufferQueue queue(2, lock);
+    TestThread thread(lock, queue);
+
+    ASSERT_TRUE(thread.start());
+    ASSERT_TRUE(thread.startPush(Buffer("Hello World")));
+    EXPECT_EQ(IoResult::Ok, thread.endPush());
+
+    // Closing the queue shall not prevent pulling items from it.
+    // After that, IoResult::Error shall be returned.
+    thread.doClose();
+
+    ASSERT_TRUE(thread.startPush(Buffer("Foo Bar")));
+    EXPECT_EQ(IoResult::Error, thread.endPush());
+
+    lock.lock();
+    Buffer buffer;
+    EXPECT_EQ(IoResult::Ok, queue.popLocked(&buffer));
+    EXPECT_STREQ("Hello World", buffer.data());
+
+    EXPECT_EQ(IoResult::Error, queue.popLocked(&buffer));
+    EXPECT_STREQ("Hello World", buffer.data());
+    lock.unlock();
+
+    thread.stop();
+}
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.cpp b/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.cpp
index db0589b..0f402b9 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.cpp
+++ b/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.cpp
@@ -13,42 +13,81 @@
 // limitations under the License.
 #include "ChannelStream.h"
 
-#include <assert.h>
+#include "OpenglRender/RenderChannel.h"
 
-ChannelStream::ChannelStream(std::shared_ptr<emugl::RenderChannelImpl> channel,
+#define EMUGL_DEBUG_LEVEL  0
+#include "emugl/common/debug.h"
+
+#include <assert.h>
+#include <memory.h>
+
+namespace emugl {
+
+using IoResult = RenderChannel::IoResult;
+
+ChannelStream::ChannelStream(std::shared_ptr<RenderChannelImpl> channel,
                              size_t bufSize)
     : IOStream(bufSize), mChannel(channel) {
-    mBuf.resize_noinit(bufSize);
+    mWriteBuffer.resize_noinit(bufSize);
 }
 
 void* ChannelStream::allocBuffer(size_t minSize) {
-    if (mBuf.size() < minSize) {
-        mBuf.resize_noinit(minSize);
+    if (mWriteBuffer.size() < minSize) {
+        mWriteBuffer.resize_noinit(minSize);
     }
-    return mBuf.data();
+    return mWriteBuffer.data();
 }
 
 int ChannelStream::commitBuffer(size_t size) {
-    assert(size <= mBuf.size());
-    if (mBuf.isAllocated()) {
-        mBuf.resize(size);
-        mChannel->writeToGuest(std::move(mBuf));
+    assert(size <= mWriteBuffer.size());
+    if (mWriteBuffer.isAllocated()) {
+        mWriteBuffer.resize(size);
+        mChannel->writeToGuest(std::move(mWriteBuffer));
     } else {
         mChannel->writeToGuest(
-                emugl::ChannelBuffer(mBuf.data(), mBuf.data() + size));
+                RenderChannel::Buffer(mWriteBuffer.data(), mWriteBuffer.data() + size));
     }
     return size;
 }
 
-const unsigned char* ChannelStream::read(void* buf, size_t* inout_len) {
-    size_t size = mChannel->readFromGuest((char*)buf, *inout_len, true);
-    if (size == 0) {
+const unsigned char* ChannelStream::readRaw(void* buf, size_t* inout_len) {
+    size_t wanted = *inout_len;
+    size_t count = 0U;
+    auto dst = static_cast<uint8_t*>(buf);
+    D("wanted %d bytes", (int)wanted);
+    while (count < wanted) {
+        if (mReadBufferLeft > 0) {
+            size_t avail = std::min<size_t>(wanted - count, mReadBufferLeft);
+            memcpy(dst + count,
+                   mReadBuffer.data() + (mReadBuffer.size() - mReadBufferLeft),
+                   avail);
+            count += avail;
+            mReadBufferLeft -= avail;
+            continue;
+        }
+        bool blocking = (count == 0);
+        auto result = mChannel->readFromGuest(&mReadBuffer, blocking);
+        D("readFromGuest() returned %d, size %d", (int)result, (int)mReadBuffer.size());
+        if (result == IoResult::Ok) {
+            mReadBufferLeft = mReadBuffer.size();
+            continue;
+        }
+        if (count > 0) {  // There is some data to return.
+            break;
+        }
+        // Result can only be IoResult::Error if |count == 0| since |blocking|
+        // was true, it cannot be IoResult::TryAgain.
+        assert(result == IoResult::Error);
+        D("error while trying to read");
         return nullptr;
     }
-    *inout_len = size;
+    *inout_len = count;
+    D("read %d bytes", (int)count);
     return (const unsigned char*)buf;
 }
 
 void ChannelStream::forceStop() {
-    mChannel->stop();
+    mChannel->stopFromHost();
 }
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.h b/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.h
index 0a2d5f4..02b2fe7 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.h
+++ b/distrib/android-emugl/host/libs/libOpenglRender/ChannelStream.h
@@ -13,25 +13,32 @@
 // limitations under the License.
 #pragma once
 
-#include "IOStream.h"
+#include "OpenglRender/IOStream.h"
 #include "RenderChannelImpl.h"
 
 #include <memory>
-#include <vector>
 
+namespace emugl {
+
+// An IOStream instance that can be used by the host RenderThread to
+// wrap a RenderChannelImpl channel.
 class ChannelStream final : public IOStream {
 public:
-    ChannelStream(std::shared_ptr<emugl::RenderChannelImpl> channel,
-                  size_t bufSize);
-
-    virtual void* allocBuffer(size_t minSize) override final;
-    virtual int commitBuffer(size_t size) override final;
-    virtual const unsigned char* read(void* buf,
-                                      size_t* inout_len) override final;
+    ChannelStream(std::shared_ptr<RenderChannelImpl> channel, size_t bufSize);
 
     void forceStop();
 
+protected:
+    virtual void* allocBuffer(size_t minSize) override final;
+    virtual int commitBuffer(size_t size) override final;
+    virtual const unsigned char* readRaw(void* buf, size_t* inout_len)
+            override final;
+
 private:
-    std::shared_ptr<emugl::RenderChannelImpl> mChannel;
-    emugl::ChannelBuffer mBuf;
+    std::shared_ptr<RenderChannelImpl> mChannel;
+    RenderChannel::Buffer mWriteBuffer;
+    RenderChannel::Buffer mReadBuffer;
+    size_t mReadBufferLeft = 0;
 };
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.cpp b/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.cpp
index 9f616b8..46851a3 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.cpp
+++ b/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.cpp
@@ -23,6 +23,8 @@
 #include <string.h>
 #include <limits.h>
 
+namespace emugl {
+
 ReadBuffer::ReadBuffer(size_t bufsize) {
     m_size = bufsize;
     m_buf = (unsigned char*)malloc(m_size);
@@ -97,3 +99,5 @@
     m_validData -= amount;
     m_readPtr += amount;
 }
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.h b/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.h
index c302e79..f3472ac 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.h
+++ b/distrib/android-emugl/host/libs/libOpenglRender/ReadBuffer.h
@@ -14,7 +14,9 @@
 * limitations under the License.
 */
 #pragma once
-#include "IOStream.h"
+#include "OpenglRender/IOStream.h"
+
+namespace emugl {
 
 class ReadBuffer {
 public:
@@ -30,3 +32,5 @@
     size_t m_size;
     size_t m_validData;
 };
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.cpp b/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.cpp
index cd8b979..db27b41 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.cpp
+++ b/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.cpp
@@ -13,6 +13,8 @@
 // limitations under the License.
 #include "RenderChannelImpl.h"
 
+#include "android/base/synchronization/Lock.h"
+
 #include <algorithm>
 #include <utility>
 
@@ -21,147 +23,130 @@
 
 namespace emugl {
 
-RenderChannelImpl::RenderChannelImpl(std::shared_ptr<RendererImpl> renderer)
-    : mRenderer(std::move(renderer)), mState(State::Empty) {
-    assert(mState.is_lock_free()); // rethink it if this fails - we've already
-                                   // got a lock, use it instead.
+#define EMUGL_DEBUG_LEVEL 0
+#include "emugl/common/debug.h"
+
+using Buffer = RenderChannel::Buffer;
+using IoResult = RenderChannel::IoResult;
+using State = RenderChannel::State;
+using AutoLock = android::base::AutoLock;
+
+// These constants correspond to the capacities of buffer queues
+// used by each RenderChannelImpl instance. Benchmarking shows that
+// it's important to have a large queue for guest -> host transfers,
+// but a much smaller one works for host -> guest ones.
+static constexpr size_t kGuestToHostQueueCapacity = 1024U;
+static constexpr size_t kHostToGuestQueueCapacity = 16U;
+
+RenderChannelImpl::RenderChannelImpl()
+    : mLock(),
+      mFromGuest(kGuestToHostQueueCapacity, mLock),
+      mToGuest(kHostToGuestQueueCapacity, mLock) {
+    updateStateLocked();
 }
 
-void RenderChannelImpl::setEventCallback(
-        RenderChannelImpl::EventCallback callback) {
-    mOnEvent = std::move(callback);
-
-    // Reset the current state to make sure the new subscriber gets it.
-    mState.store(State::Empty, std::memory_order_release);
-    onEvent(true);
+void RenderChannelImpl::setEventCallback(EventCallback&& callback) {
+    mEventCallback = std::move(callback);
 }
 
-bool RenderChannelImpl::write(ChannelBuffer&& buffer) {
-    const bool res = mFromGuest.send(std::move(buffer));
-    onEvent(true);
-    return res;
+void RenderChannelImpl::setWantedEvents(State state) {
+    D("state=%d", (int)state);
+    AutoLock lock(mLock);
+    mWantedEvents |= state;
+    notifyStateChangeLocked();
 }
 
-bool RenderChannelImpl::read(ChannelBuffer* buffer, CallType type) {
-    if (type == CallType::Nonblocking && mToGuest.size() == 0) {
-        return false;
-    }
-    const bool res = mToGuest.receive(buffer);
-    onEvent(true);
-    return res;
+RenderChannel::State RenderChannelImpl::state() const {
+    AutoLock lock(mLock);
+    return mState;
+}
+
+IoResult RenderChannelImpl::tryWrite(Buffer&& buffer) {
+    D("buffer size=%d", (int)buffer.size());
+    AutoLock lock(mLock);
+    auto result = mFromGuest.tryPushLocked(std::move(buffer));
+    updateStateLocked();
+    DD("mFromGuest.tryPushLocked() returned %d, state %d", (int)result,
+       (int)mState);
+    return result;
+}
+
+IoResult RenderChannelImpl::tryRead(Buffer* buffer) {
+    D("enter");
+    AutoLock lock(mLock);
+    auto result = mToGuest.tryPopLocked(buffer);
+    updateStateLocked();
+    DD("mToGuest.tryPopLocked() returned %d, buffer size %d, state %d",
+       (int)result, (int)buffer->size(), (int)mState);
+    return result;
 }
 
 void RenderChannelImpl::stop() {
-    stop(true);
+    D("enter");
+    AutoLock lock(mLock);
+    mFromGuest.closeLocked();
+    mToGuest.closeLocked();
 }
 
-void RenderChannelImpl::forceStop() {
-    stop(false);
+bool RenderChannelImpl::writeToGuest(Buffer&& buffer) {
+    D("buffer size=%d", (int)buffer.size());
+    AutoLock lock(mLock);
+    IoResult result = mToGuest.pushLocked(std::move(buffer));
+    updateStateLocked();
+    DD("mToGuest.pushLocked() returned %d, state %d", (int)result, (int)mState);
+    notifyStateChangeLocked();
+    return result == IoResult::Ok;
 }
 
-void RenderChannelImpl::stop(bool byGuest) {
-    if (mStopped) {
-        return;
-    }
-    mStopped = true;
-    mFromGuest.stop();
-    mToGuest.stop();
-    onEvent(byGuest);
-}
-
-bool RenderChannelImpl::isStopped() const {
-    return mStopped;
-}
-
-void RenderChannelImpl::writeToGuest(ChannelBuffer&& buf) {
-    mToGuest.send(std::move(buf));
-    onEvent(false);
-}
-
-size_t RenderChannelImpl::readFromGuest(ChannelBuffer::value_type* buf,
-                                        size_t size,
-                                        bool blocking) {
-    assert(buf);
-
-    size_t read = 0;
-    const auto bufEnd = buf + size;
-    while (buf != bufEnd && !mStopped) {
-        if (mFromGuestBufferLeft == 0) {
-            if (mFromGuest.size() == 0 && (read > 0 || !blocking)) {
-                break;
-            }
-            if (!mFromGuest.receive(&mFromGuestBuffer)) {
-                break;
-            }
-            mFromGuestBufferLeft = mFromGuestBuffer.size();
-        }
-
-        const size_t curSize =
-                std::min<size_t>(bufEnd - buf, mFromGuestBufferLeft);
-        memcpy(buf, mFromGuestBuffer.data() +
-                            (mFromGuestBuffer.size() - mFromGuestBufferLeft),
-               curSize);
-
-        read += curSize;
-        buf += curSize;
-        mFromGuestBufferLeft -= curSize;
-    }
-    onEvent(false);
-    return read;
-}
-
-void RenderChannelImpl::onEvent(bool byGuest) {
-    if (!mOnEvent) {
-        return;
-    }
-
-    // We need to make sure that the state returned from calcState() remains
-    // valid when we write it into mState; this means we need to lock both
-    // calcState() and mState assignment with the same lock - otherwise it is
-    // possible (and it happened before the lock was added) that some other
-    // thread would overwrite a newer state with its older value, e.g.:
-    //  - thread 1 reads the last message from |mToGuest|
-    //  - thread 1 enters onEvent()
-    //  - thread 1 calculates state 1 = "can't read", switches out
-    //  -   thread 2 writes some data into |mToGuest|
-    //  -   thread 2 enters onEvent()
-    //  -   thread 2 calculates state 2 = "can read"
-    //  -   thread 2 gets the lock
-    //  -   thread 2 updates |mState| to "can read", unlocks, switches out
-    //  - thread 1 gets the lock
-    //  - thread 1 overwrites |mState| with state 1 = "can't read"
-    //  - thread 1 unlocks and calls the |mOnEvent| callback.
-    //
-    // The result is that state 2 = "can read" is completely lost - callback
-    // is never called when |mState| is "can read".
-    //
-    // But if the whole block of code is locked, threads can't overwrite newer
-    // |mState| with some older value, and the described situation would never
-    // happen.
-    android::base::AutoLock lock(mStateLock);
-    const State newState = calcState();
-    if (mState != newState) {
-        mState = newState;
-        lock.unlock();
-
-        mOnEvent(newState,
-                 byGuest ? EventSource::Client : EventSource::RenderChannel);
-    }
-}
-
-RenderChannel::State RenderChannelImpl::calcState() const {
-    State state = State::Empty;
-    if (mStopped) {
-        state = State::Stopped;
+IoResult RenderChannelImpl::readFromGuest(Buffer* buffer, bool blocking) {
+    D("enter");
+    AutoLock lock(mLock);
+    IoResult result;
+    if (blocking) {
+        result = mFromGuest.popLocked(buffer);
     } else {
-        if (mFromGuest.size() < mFromGuest.capacity()) {
-            state |= State::CanWrite;
-        }
-        if (mToGuest.size() > 0) {
-            state |= State::CanRead;
-        }
+        result = mFromGuest.tryPopLocked(buffer);
     }
-    return state;
+    updateStateLocked();
+    DD("mFromGuest.%s() return %d, buffer size %d, state %d",
+       blocking ? "popLocked" : "tryPopLocked", (int)result,
+       (int)buffer->size(), (int)mState);
+    notifyStateChangeLocked();
+    return result;
+}
+
+void RenderChannelImpl::stopFromHost() {
+    D("enter");
+
+    AutoLock lock(mLock);
+    mFromGuest.closeLocked();
+    mToGuest.closeLocked();
+    mState |= State::Stopped;
+    notifyStateChangeLocked();
+}
+
+void RenderChannelImpl::updateStateLocked() {
+    State state = RenderChannel::State::Empty;
+
+    if (mToGuest.canPopLocked()) {
+        state |= State::CanRead;
+    }
+    if (mFromGuest.canPushLocked()) {
+        state |= State::CanWrite;
+    }
+    if (mToGuest.isClosedLocked()) {
+        state |= State::Stopped;
+    }
+    mState = state;
+}
+
+void RenderChannelImpl::notifyStateChangeLocked() {
+    State available = mState & mWantedEvents;
+    if (available != 0) {
+        D("callback with %d", (int)available);
+        mWantedEvents &= ~mState;
+        mEventCallback(available);
+    }
 }
 
 }  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.h b/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.h
index eca2966..0d306d1 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.h
+++ b/distrib/android-emugl/host/libs/libOpenglRender/RenderChannelImpl.h
@@ -14,80 +14,76 @@
 #pragma once
 
 #include "OpenglRender/RenderChannel.h"
+#include "BufferQueue.h"
 #include "RendererImpl.h"
 
-#include "android/base/Compiler.h"
-#include "android/base/synchronization/Lock.h"
-#include "android/base/synchronization/MessageChannel.h"
-
-#include <atomic>
-#include <memory>
-
 namespace emugl {
 
+// Implementation of the RenderChannel interface that connects a guest
+// client thread (really an AndroidPipe implementation) to a host
+// RenderThread instance.
 class RenderChannelImpl final : public RenderChannel {
 public:
-    RenderChannelImpl(std::shared_ptr<RendererImpl> renderer);
+    // Default constructor.
+    RenderChannelImpl();
 
-public:
-    // RenderChannel implementation, operations provided for a guest system
-    virtual void setEventCallback(EventCallback callback) override final;
+    /////////////////////////////////////////////////////////////////
+    // RenderChannel overriden methods. These are called from the guest
+    // client thread.
 
-    virtual bool write(ChannelBuffer&& buffer) override final;
-    virtual bool read(ChannelBuffer* buffer, CallType type) override final;
+    // Set the event |callback| to be notified when the host changes the
+    // state of the channel, according to the event mask provided by
+    // setWantedEvents(). Call this function right after creating the
+    // instance.
+    virtual void setEventCallback(EventCallback&& callback) override final;
 
-    virtual State currentState() const override final {
-        return mState.load(std::memory_order_acquire);
-    }
+    // Set the mask of events the guest wants to be notified of from the
+    // host thread.
+    virtual void setWantedEvents(State state) override final;
 
+    // Return the current channel state relative to the guest.
+    virtual State state() const override final;
+
+    // Try to send a buffer from the guest to the host render thread.
+    virtual IoResult tryWrite(Buffer&& buffer) override final;
+
+    // Try to read a buffer from the host render thread into the guest.
+    virtual IoResult tryRead(Buffer* buffer) override final;
+
+    // Close the channel from the guest.
     virtual void stop() override final;
-    virtual bool isStopped() const override final;
 
-public:
-    // These functions are for the RenderThread, they could be called in
-    // parallel with the ones from the RenderChannel interface. Make sure the
-    // internal state remains consistent all the time.
-    void writeToGuest(ChannelBuffer&& buf);
-    size_t readFromGuest(ChannelBuffer::value_type* buf, size_t size,
-                         bool blocking);
-    void forceStop();
+    /////////////////////////////////////////////////////////////////
+    // These functions are called from the host render thread.
+
+    // Send a buffer to the guest, this call is blocking. On success,
+    // move |buffer| into the channel and return true. On failure, return
+    // false (meaning that the channel was closed).
+    bool writeToGuest(Buffer&& buffer);
+
+    // Read data from the guest. If |blocking| is true, the call will be
+    // blocking. On success, move item into |*buffer| and return true. On
+    // failure, return IoResult::Error to indicate the channel was closed,
+    // or IoResult::TryAgain to indicate it was empty (this can happen only
+    // if |blocking| is false).
+    IoResult readFromGuest(Buffer* buffer, bool blocking);
+
+    // Close the channel from the host.
+    void stopFromHost();
 
 private:
-    DISALLOW_COPY_ASSIGN_AND_MOVE(RenderChannelImpl);
+    void updateStateLocked();
+    void notifyStateChangeLocked();
 
-private:
-    void onEvent(bool byGuest);
-    State calcState() const;
-    void stop(bool byGuest);
+    EventCallback mEventCallback;
 
-private:
-    std::shared_ptr<RendererImpl> mRenderer;
-
-    EventCallback mOnEvent;
-
-    // Protects the state recalculation and writes to mState.
-    //
-    // The correctness condition governing the relationship between mFromGuest,
-    // mToGuest, and mState is that we can't reach a potentially stable state
-    // (i.e., at the end of a set of invocations of publically-visible
-    // operations) in which either:
-    //  - mFromGuest().size() < mFromGuest.capacity(), yet state does not have
-    //    State::CanWrite, or
-    //  - mToGuest().size > 0, yet state does not have State::CanRead.
-    // Clients assume they can poll currentState() and have the indicate whether
-    // a write or read might possibly succeed, and this correctness condition
-    // makes that assumption valid -- if a write or read might succeed,
-    // mState is required to eventually indicate this.
-    android::base::Lock mStateLock;
-    std::atomic<State> mState;
-
-    bool mStopped = false;
-
-    android::base::MessageChannel<ChannelBuffer, 1024> mFromGuest;
-    android::base::MessageChannel<ChannelBuffer, 16> mToGuest;
-
-    ChannelBuffer mFromGuestBuffer;
-    size_t mFromGuestBufferLeft = 0;
+    // A single lock to protect the state and the two buffer queues at the
+    // same time. NOTE: This needs to appear before the BufferQueue instances.
+    mutable android::base::Lock mLock;
+    State mState = State::Empty;
+    State mWantedEvents = State::Empty;
+    BufferQueue mFromGuest;
+    BufferQueue mToGuest;
 };
 
 }  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.cpp b/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.cpp
index bf7f45f..a34c985 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.cpp
+++ b/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.cpp
@@ -31,38 +31,43 @@
 
 #include "android/base/system/System.h"
 
+#define EMUGL_DEBUG_LEVEL 0
+#include "emugl/common/debug.h"
+
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 
+namespace emugl {
+
 // Start with a smaller buffer to not waste memory on a low-used render threads.
 static constexpr int kStreamBufferSize = 128 * 1024;
 
-RenderThread::RenderThread(std::weak_ptr<emugl::RendererImpl> renderer,
-                           std::shared_ptr<emugl::RenderChannelImpl> channel)
+RenderThread::RenderThread(std::weak_ptr<RendererImpl> renderer,
+                           std::shared_ptr<RenderChannelImpl> channel)
     : mChannel(channel), mRenderer(renderer) {}
 
 RenderThread::~RenderThread() = default;
 
 // static
 std::unique_ptr<RenderThread> RenderThread::create(
-        std::weak_ptr<emugl::RendererImpl> renderer,
-        std::shared_ptr<emugl::RenderChannelImpl> channel) {
+        std::weak_ptr<RendererImpl> renderer,
+        std::shared_ptr<RenderChannelImpl> channel) {
     return std::unique_ptr<RenderThread>(
             new RenderThread(renderer, channel));
 }
 
 intptr_t RenderThread::main() {
+    ChannelStream stream(mChannel, RenderChannel::Buffer::kSmallSize);
+
     uint32_t flags = 0;
-    if (mChannel->readFromGuest(reinterpret_cast<char*>(&flags),
-                                sizeof(flags), true) != sizeof(flags)) {
+    if (stream.read(&flags, sizeof(flags)) != sizeof(flags)) {
         return 0;
     }
 
     // |flags| used to have something, now they're not used.
     (void)flags;
 
-    ChannelStream stream(mChannel, emugl::ChannelBuffer::kSmallSize);
     RenderThreadInfo tInfo;
     ChecksumCalculatorThreadInfo tChecksumInfo;
     ChecksumCalculator& checksumCalc = tChecksumInfo.get();
@@ -114,8 +119,12 @@
 
         const int stat = readBuf.getData(&stream, packetSize);
         if (stat <= 0) {
+            D("Warning: render thread could not read data from stream");
             break;
         }
+        DD("render thread read %d bytes, op %d, packet size %d",
+           (int)readBuf.validData(), *(int32_t*)readBuf.buf(),
+           *(int32_t*)(readBuf.buf() + 4));
 
         //
         // log received bandwidth statistics
@@ -214,3 +223,5 @@
 
     return 0;
 }
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.h b/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.h
index 7b4b63e..723f274 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.h
+++ b/distrib/android-emugl/host/libs/libOpenglRender/RenderThread.h
@@ -14,7 +14,6 @@
 * limitations under the License.
 */
 #pragma once
-#include "IOStream.h"
 
 #include "emugl/common/mutex.h"
 #include "emugl/common/thread.h"
@@ -22,9 +21,9 @@
 #include <memory>
 
 namespace emugl {
+
 class RenderChannelImpl;
 class RendererImpl;
-}
 
 // A class used to model a thread of the RenderServer. Each one of them
 // handles a single guest client / protocol byte stream.
@@ -32,8 +31,8 @@
 public:
     // Create a new RenderThread instance.
     static std::unique_ptr<RenderThread> create(
-            std::weak_ptr<emugl::RendererImpl> renderer,
-            std::shared_ptr<emugl::RenderChannelImpl> channel);
+            std::weak_ptr<RendererImpl> renderer,
+            std::shared_ptr<RenderChannelImpl> channel);
 
     virtual ~RenderThread();
 
@@ -42,11 +41,13 @@
     bool isFinished() { return tryWait(NULL); }
 
 private:
-    RenderThread(std::weak_ptr<emugl::RendererImpl> renderer,
-                 std::shared_ptr<emugl::RenderChannelImpl> channel);
+    RenderThread(std::weak_ptr<RendererImpl> renderer,
+                 std::shared_ptr<RenderChannelImpl> channel);
 
     virtual intptr_t main();
 
-    std::shared_ptr<emugl::RenderChannelImpl> mChannel;
-    std::weak_ptr<emugl::RendererImpl> mRenderer;
+    std::shared_ptr<RenderChannelImpl> mChannel;
+    std::weak_ptr<RendererImpl> mRenderer;
 };
+
+}  // namespace emugl
diff --git a/distrib/android-emugl/host/libs/libOpenglRender/RendererImpl.cpp b/distrib/android-emugl/host/libs/libOpenglRender/RendererImpl.cpp
index ff14aac..68d646f 100644
--- a/distrib/android-emugl/host/libs/libOpenglRender/RendererImpl.cpp
+++ b/distrib/android-emugl/host/libs/libOpenglRender/RendererImpl.cpp
@@ -92,7 +92,7 @@
 
     for (const auto& t : threads) {
         if (const auto channel = t.second.lock()) {
-            channel->forceStop();
+            channel->stopFromHost();
         }
     }
     // We're stopping the renderer, so there's no need to clean up resources
@@ -106,8 +106,7 @@
 }
 
 RenderChannelPtr RendererImpl::createRenderChannel() {
-    const auto channel =
-            std::make_shared<RenderChannelImpl>(shared_from_this());
+    const auto channel = std::make_shared<RenderChannelImpl>();
 
     std::unique_ptr<RenderThread> rt(RenderThread::create(
             shared_from_this(), channel));
diff --git a/distrib/android-emugl/host/tools/emugen/ApiGen.cpp b/distrib/android-emugl/host/tools/emugen/ApiGen.cpp
index 8af6e29..fc51ebc 100644
--- a/distrib/android-emugl/host/tools/emugen/ApiGen.cpp
+++ b/distrib/android-emugl/host/tools/emugen/ApiGen.cpp
@@ -803,7 +803,7 @@
     fprintf(fp, "\n#ifndef GUARD_%s\n", classname.c_str());
     fprintf(fp, "#define GUARD_%s\n\n", classname.c_str());
 
-    fprintf(fp, "#include \"IOStream.h\"\n");
+    fprintf(fp, "#include \"OpenglRender/IOStream.h\"\n");
     fprintf(fp, "#include \"ChecksumCalculator.h\"\n");
     fprintf(fp, "#include \"%s_%s_context.h\"\n\n\n", m_basename.c_str(), sideString(SERVER_SIDE));
     fprintf(fp, "#include \"emugl/common/logging.h\"\n");
diff --git a/distrib/android-emugl/host/tools/emugen/tests/t.001/expected/decoder/foo_dec.h b/distrib/android-emugl/host/tools/emugen/tests/t.001/expected/decoder/foo_dec.h
index 30ada6f..d025090 100644
--- a/distrib/android-emugl/host/tools/emugen/tests/t.001/expected/decoder/foo_dec.h
+++ b/distrib/android-emugl/host/tools/emugen/tests/t.001/expected/decoder/foo_dec.h
@@ -4,7 +4,7 @@
 #ifndef GUARD_foo_decoder_context_t
 #define GUARD_foo_decoder_context_t
 
-#include "IOStream.h"
+#include "OpenglRender/IOStream.h"
 #include "ChecksumCalculator.h"
 #include "foo_server_context.h"
 
diff --git a/distrib/android-emugl/shared/OpenglCodecCommon/Android.mk b/distrib/android-emugl/shared/OpenglCodecCommon/Android.mk
index 509812a..e5cefae 100644
--- a/distrib/android-emugl/shared/OpenglCodecCommon/Android.mk
+++ b/distrib/android-emugl/shared/OpenglCodecCommon/Android.mk
@@ -17,7 +17,7 @@
 
 LOCAL_SRC_FILES := $(host_commonSources)
 $(call emugl-import, libemugl_common)
-$(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/host/include/libOpenglRender $(LOCAL_PATH))
+$(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/host/include/OpenglRender $(LOCAL_PATH))
 $(call emugl-export,LDLIBS,$(host_commonLdLibs))
 $(call emugl-end-module)
 
diff --git a/distrib/android-emugl/shared/emugl/common/debug.h b/distrib/android-emugl/shared/emugl/common/debug.h
new file mode 100644
index 0000000..d431381
--- /dev/null
+++ b/distrib/android-emugl/shared/emugl/common/debug.h
@@ -0,0 +1,33 @@
+/*
+* Copyright (C) 2016 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#pragma once
+
+// Usage: Define EMUGL_DEBUG_LEVEL before including this header to
+//        select the behaviour of the D() and DD() macros.
+
+#if defined(EMUGL_DEBUG_LEVEL) && EMUGL_DEBUG_LEVEL > 0
+#include <stdio.h>
+#define D(...)  (printf("%s:%d:%s: ", __FILE__, __LINE__, __func__), printf(__VA_ARGS__), printf("\n"), fflush(stdout))
+#else
+#define D(...)  (void)0
+#endif // EMUGL_DEBUG_LEVEL > 0
+
+#if defined(EMUGL_DEBUG_LEVEL) && EMUGL_DEBUG_LEVEL > 1
+#define DD(...) D(__VA_ARGS__)
+#else
+#define DD(...) (void)0
+#endif // EMUGL_DEBUG_LEVEL > 1