diff --git a/opengl/libs/GLES_trace/src/gltrace_eglapi.cpp b/opengl/libs/GLES_trace/src/gltrace_eglapi.cpp
index c442153..9698bf9 100644
--- a/opengl/libs/GLES_trace/src/gltrace_eglapi.cpp
+++ b/opengl/libs/GLES_trace/src/gltrace_eglapi.cpp
@@ -44,9 +44,14 @@
     GLTraceState *state = (GLTraceState *)arg;
     TCPStream *stream = state->getStream();
 
-    // Currently, there are very few user configurable settings.
-    // As a result, they can be encoded in a single integer.
-    int cmd;
+    // The control stream always receives an integer size of the
+    // command buffer, followed by the actual command buffer.
+    uint32_t cmdSize;
+
+    // Command Buffer
+    void *cmdBuf = NULL;
+    uint32_t cmdBufSize = 0;
+
     enum TraceSettingsMasks {
         READ_FB_ON_EGLSWAP_MASK = 1 << 0,
         READ_FB_ON_GLDRAW_MASK = 1 << 1,
@@ -54,12 +59,33 @@
     };
 
     while (true) {
-        int n = stream->receive(&cmd, 4);
-        if (n != 4) {
+        // read command size
+        if (stream->receive(&cmdSize, sizeof(uint32_t)) < 0) {
+            break;
+        }
+        cmdSize = ntohl(cmdSize);
+
+        // ensure command buffer is of required size
+        if (cmdBufSize < cmdSize) {
+            free(cmdBuf);
+            cmdBufSize = cmdSize;
+            cmdBuf = malloc(cmdSize);
+            if (cmdBuf == NULL)
+                break;
+        }
+
+        // receive the command
+        if (stream->receive(cmdBuf, cmdSize) < 0) {
             break;
         }
 
-        cmd = ntohl(cmd);
+        if (cmdSize != sizeof(uint32_t)) {
+            // Currently, we only support commands that are a single integer,
+            // so we skip all other commands
+            continue;
+        }
+
+        uint32_t cmd = ntohl(*(uint32_t*)cmdBuf);
 
         bool collectFbOnEglSwap = (cmd & READ_FB_ON_EGLSWAP_MASK) != 0;
         bool collectFbOnGlDraw = (cmd & READ_FB_ON_GLDRAW_MASK) != 0;
@@ -73,6 +99,9 @@
             collectFbOnEglSwap, collectFbOnGlDraw, collectTextureData);
     }
 
+    ALOGE("Stopping OpenGL Trace Command Receiver\n");
+
+    free(cmdBuf);
     return NULL;
 }
 
diff --git a/opengl/libs/GLES_trace/src/gltrace_transport.cpp b/opengl/libs/GLES_trace/src/gltrace_transport.cpp
index 157bd24..2996d32 100644
--- a/opengl/libs/GLES_trace/src/gltrace_transport.cpp
+++ b/opengl/libs/GLES_trace/src/gltrace_transport.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <errno.h>
 #include <stdlib.h>
 #include <unistd.h>
 
@@ -123,7 +124,18 @@
         return -1;
     }
 
-    return read(mSocket, data, len);
+    size_t totalRead = 0;
+    while (totalRead < len) {
+        int n = read(mSocket, (uint8_t*)data + totalRead, len - totalRead);
+        if (n < 0) {
+            ALOGE("Error receiving data from stream: %d", errno);
+            return -1;
+        }
+
+        totalRead += n;
+    }
+
+    return 0;
 }
 
 BufferedOutputStream::BufferedOutputStream(TCPStream *stream, size_t bufferSize) {
diff --git a/opengl/libs/GLES_trace/src/gltrace_transport.h b/opengl/libs/GLES_trace/src/gltrace_transport.h
index 3665035..9cf5b45 100644
--- a/opengl/libs/GLES_trace/src/gltrace_transport.h
+++ b/opengl/libs/GLES_trace/src/gltrace_transport.h
@@ -42,8 +42,11 @@
     /** Send @data of size @len to host. . Returns -1 on error, 0 on success. */
     int send(void *data, size_t len);
 
-    /** Receive data into @buf from the remote end. This is a blocking call. */
-    int receive(void *buf, size_t size);
+    /**
+     * Receive @len bytes of data into @buf from the remote end. This is a blocking call.
+     * Returns -1 on failure, 0 on success.
+     */
+    int receive(void *buf, size_t len);
 };
 
 /**
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 7eba89b..6ec4f49 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -232,27 +232,28 @@
     // ... then reduce that in the same proportions as the window crop reduces
     // the window size.
     const State& s(drawingState());
-    if (!s.crop.isEmpty()) {
+    if (!s.active.crop.isEmpty()) {
         // Transform the window crop to match the buffer coordinate system,
         // which means using the inverse of the current transform set on the
         // SurfaceTexture.
         uint32_t invTransform = mCurrentTransform;
-        int winWidth = s.w;
-        int winHeight = s.h;
+        int winWidth = s.active.w;
+        int winHeight = s.active.h;
         if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
             invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |
                     NATIVE_WINDOW_TRANSFORM_FLIP_H;
-            winWidth = s.h;
-            winHeight = s.w;
+            winWidth = s.active.h;
+            winHeight = s.active.w;
         }
-        Rect winCrop = s.crop.transform(invTransform, s.w, s.h);
+        Rect winCrop = s.active.crop.transform(invTransform,
+                s.active.w, s.active.h);
 
         float xScale = float(crop.width()) / float(winWidth);
         float yScale = float(crop.height()) / float(winHeight);
-        crop.left += int(ceil(float(winCrop.left) * xScale));
-        crop.top += int(ceil(float(winCrop.top) * yScale));
-        crop.right -= int(ceil(float(winWidth - winCrop.right) * xScale));
-        crop.bottom -= int(ceil(float(winHeight - winCrop.bottom) * yScale));
+        crop.left += int(ceilf(float(winCrop.left) * xScale));
+        crop.top += int(ceilf(float(winCrop.top) * yScale));
+        crop.right -= int(ceilf(float(winWidth - winCrop.right) * xScale));
+        crop.bottom -= int(ceilf(float(winHeight - winCrop.bottom) * yScale));
     }
 
     return crop;
@@ -427,32 +428,44 @@
     const Layer::State& front(drawingState());
     const Layer::State& temp(currentState());
 
-    const bool sizeChanged = (front.requested_w != temp.requested_w) ||
-            (front.requested_h != temp.requested_h);
+    const bool sizeChanged = (front.requested.w != temp.requested.w) ||
+            (front.requested.h != temp.requested.h);
 
     if (sizeChanged) {
         // the size changed, we need to ask our client to request a new buffer
         ALOGD_IF(DEBUG_RESIZE,
                 "doTransaction: "
-                "resize (layer=%p), requested (%dx%d), drawing (%d,%d), "
+                "geometry (layer=%p), size: current (%dx%d), drawing (%dx%d), "
+                "crop: current (%d,%d,%d,%d [%dx%d]), drawing (%d,%d,%d,%d [%dx%d]), "
                 "scalingMode=%d",
                 this,
-                int(temp.requested_w), int(temp.requested_h),
-                int(front.requested_w), int(front.requested_h),
+                int(temp.requested.w), int(temp.requested.h),
+                int(front.requested.w), int(front.requested.h),
+                temp.requested.crop.left,
+                temp.requested.crop.top,
+                temp.requested.crop.right,
+                temp.requested.crop.bottom,
+                temp.requested.crop.getWidth(),
+                temp.requested.crop.getHeight(),
+                front.requested.crop.left,
+                front.requested.crop.top,
+                front.requested.crop.right,
+                front.requested.crop.bottom,
+                front.requested.crop.getWidth(),
+                front.requested.crop.getHeight(),
                 mCurrentScalingMode);
 
         if (!isFixedSize()) {
             // this will make sure LayerBase::doTransaction doesn't update
-            // the drawing state's size
+            // the drawing state's geometry
             Layer::State& editDraw(mDrawingState);
-            editDraw.requested_w = temp.requested_w;
-            editDraw.requested_h = temp.requested_h;
+            editDraw.requested = temp.requested;
         }
 
         // record the new size, form this point on, when the client request
         // a buffer, it'll get the new size.
-        mSurfaceTexture->setDefaultBufferSize(temp.requested_w,
-                temp.requested_h);
+        mSurfaceTexture->setDefaultBufferSize(
+                temp.requested.w, temp.requested.h);
     }
 
     return LayerBase::doTransaction(flags);
@@ -551,11 +564,9 @@
         const Layer::State& front(drawingState());
 
         // FIXME: mPostedDirtyRegion = dirty & bounds
-        mPostedDirtyRegion.set(front.w, front.h);
+        mPostedDirtyRegion.set(front.active.w, front.active.h);
 
-        if ((front.w != front.requested_w) ||
-            (front.h != front.requested_h))
-        {
+        if (front.active != front.requested) {
             // check that we received a buffer of the right size
             // (Take the buffer's orientation into account)
             if (mCurrentTransform & Transform::ROT_90) {
@@ -563,15 +574,14 @@
             }
 
             if (isFixedSize() ||
-                    (bufWidth == front.requested_w &&
-                    bufHeight == front.requested_h))
+                    (bufWidth == front.requested.w &&
+                    bufHeight == front.requested.h))
             {
                 // Here we pretend the transaction happened by updating the
                 // current and drawing states. Drawing state is only accessed
                 // in this thread, no need to have it locked
                 Layer::State& editDraw(mDrawingState);
-                editDraw.w = editDraw.requested_w;
-                editDraw.h = editDraw.requested_h;
+                editDraw.active = editDraw.requested;
 
                 // We also need to update the current state so that we don't
                 // end-up doing too much work during the next transaction.
@@ -579,8 +589,7 @@
                 // because State::w and State::h are only accessed from
                 // this thread
                 Layer::State& editTemp(currentState());
-                editTemp.w = editDraw.w;
-                editTemp.h = editDraw.h;
+                editTemp.active = editDraw.active;
 
                 // recompute visible region
                 recomputeVisibleRegions = true;
@@ -592,7 +601,7 @@
                     "requested (%dx%d)",
                     this,
                     bufWidth, bufHeight, mCurrentTransform,
-                    front.requested_w, front.requested_h);
+                    front.requested.w, front.requested.h);
         }
     }
 }
diff --git a/services/surfaceflinger/LayerBase.cpp b/services/surfaceflinger/LayerBase.cpp
index 81031b1..7c6a28a 100644
--- a/services/surfaceflinger/LayerBase.cpp
+++ b/services/surfaceflinger/LayerBase.cpp
@@ -84,16 +84,15 @@
     if (flags & ISurfaceComposer::eNonPremultiplied)
         mPremultipliedAlpha = false;
 
-    mCurrentState.z             = 0;
-    mCurrentState.w             = w;
-    mCurrentState.h             = h;
-    mCurrentState.requested_w   = w;
-    mCurrentState.requested_h   = h;
-    mCurrentState.alpha         = 0xFF;
-    mCurrentState.flags         = layerFlags;
-    mCurrentState.sequence      = 0;
+    mCurrentState.active.w = w;
+    mCurrentState.active.h = h;
+    mCurrentState.active.crop.makeInvalid();
+    mCurrentState.z = 0;
+    mCurrentState.alpha = 0xFF;
+    mCurrentState.flags = layerFlags;
+    mCurrentState.sequence = 0;
     mCurrentState.transform.set(0, 0);
-    mCurrentState.crop.makeInvalid();
+    mCurrentState.requested = mCurrentState.active;
 
     // drawing state & current state are identical
     mDrawingState = mCurrentState;
@@ -136,10 +135,10 @@
     return true;
 }
 bool LayerBase::setSize(uint32_t w, uint32_t h) {
-    if (mCurrentState.requested_w == w && mCurrentState.requested_h == h)
+    if (mCurrentState.requested.w == w && mCurrentState.requested.h == h)
         return false;
-    mCurrentState.requested_w = w;
-    mCurrentState.requested_h = h;
+    mCurrentState.requested.w = w;
+    mCurrentState.requested.h = h;
     requestTransaction();
     return true;
 }
@@ -174,10 +173,10 @@
     return true;
 }
 bool LayerBase::setCrop(const Rect& crop) {
-    if (mCurrentState.crop == crop)
+    if (mCurrentState.requested.crop == crop)
         return false;
     mCurrentState.sequence++;
-    mCurrentState.crop = crop;
+    mCurrentState.requested.crop = crop;
     requestTransaction();
     return true;
 }
@@ -202,15 +201,13 @@
     const Layer::State& front(drawingState());
     const Layer::State& temp(currentState());
 
-    if ((front.requested_w != temp.requested_w) ||
-        (front.requested_h != temp.requested_h))  {
-        // resize the layer, set the physical size to the requested size
+    if (front.requested != temp.requested)  {
+        // geometry of the layer has changed, set the active geometry
+        // to the requested geometry.
         Layer::State& editTemp(currentState());
-        editTemp.w = temp.requested_w;
-        editTemp.h = temp.requested_h;
+        editTemp.active = temp.requested;
     }
-
-    if ((front.w != temp.w) || (front.h != temp.h)) {
+    if (front.active != temp.active) {
         // invalidate and recompute the visible regions if needed
         flags |= Layer::eVisibleRegion;
     }
@@ -238,9 +235,9 @@
     const bool transformed = tr.transformed();
     const DisplayHardware& hw(graphicPlane(0).displayHardware());
     const uint32_t hw_h = hw.getHeight();
-    const Rect& crop(s.crop);
+    const Rect& crop(s.active.crop);
 
-    Rect win(s.w, s.h);
+    Rect win(s.active.w, s.active.h);
     if (!crop.isEmpty()) {
         win.intersect(crop, &win);
     }
@@ -403,14 +400,14 @@
         GLfloat v;
     };
 
-    Rect crop(s.w, s.h);
-    if (!s.crop.isEmpty()) {
-        crop = s.crop;
+    Rect crop(s.active.w, s.active.h);
+    if (!s.active.crop.isEmpty()) {
+        crop = s.active.crop;
     }
-    GLfloat left = GLfloat(crop.left) / GLfloat(s.w);
-    GLfloat top = GLfloat(crop.top) / GLfloat(s.h);
-    GLfloat right = GLfloat(crop.right) / GLfloat(s.w);
-    GLfloat bottom = GLfloat(crop.bottom) / GLfloat(s.h);
+    GLfloat left = GLfloat(crop.left) / GLfloat(s.active.w);
+    GLfloat top = GLfloat(crop.top) / GLfloat(s.active.h);
+    GLfloat right = GLfloat(crop.right) / GLfloat(s.active.w);
+    GLfloat bottom = GLfloat(crop.bottom) / GLfloat(s.active.h);
 
     TexCoords texCoords[4];
     texCoords[0].u = left;
@@ -449,10 +446,12 @@
 
     snprintf(buffer, SIZE,
             "      "
-            "z=%9d, pos=(%g,%g), size=(%4d,%4d), "
+            "z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), "
             "isOpaque=%1d, needsDithering=%1d, invalidate=%1d, "
             "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
-            s.z, s.transform.tx(), s.transform.ty(), s.w, s.h,
+            s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h,
+            s.active.crop.left, s.active.crop.top,
+            s.active.crop.right, s.active.crop.bottom,
             isOpaque(), needsDithering(), contentDirty,
             s.alpha, s.flags,
             s.transform[0][0], s.transform[0][1],
diff --git a/services/surfaceflinger/LayerBase.h b/services/surfaceflinger/LayerBase.h
index 31f6dfd..9542424 100644
--- a/services/surfaceflinger/LayerBase.h
+++ b/services/surfaceflinger/LayerBase.h
@@ -65,20 +65,28 @@
             Region      coveredRegionScreen;
             int32_t     sequence;
             
+            struct Geometry {
+                uint32_t w;
+                uint32_t h;
+                Rect crop;
+                inline bool operator == (const Geometry& rhs) const {
+                    return (w==rhs.w && h==rhs.h && crop==rhs.crop);
+                }
+                inline bool operator != (const Geometry& rhs) const {
+                    return !operator == (rhs);
+                }
+            };
+
             struct State {
-                uint32_t        w;
-                uint32_t        h;
-                uint32_t        requested_w;
-                uint32_t        requested_h;
+                Geometry        active;
+                Geometry        requested;
                 uint32_t        z;
                 uint8_t         alpha;
                 uint8_t         flags;
                 uint8_t         reserved[2];
                 int32_t         sequence;   // changes when visible regions can change
-                uint32_t        tint;
                 Transform       transform;
                 Region          transparentRegion;
-                Rect            crop;
             };
 
     virtual void setName(const String8& name);