diff --git a/libs/hwui/Android.mk b/libs/hwui/Android.mk
index 8c388d9..495ad19 100644
--- a/libs/hwui/Android.mk
+++ b/libs/hwui/Android.mk
@@ -17,6 +17,7 @@
 		Caches.cpp \
 		DisplayList.cpp \
 		DeferredDisplayList.cpp \
+		DeferredLayerUpdater.cpp \
 		DisplayListLogBuffer.cpp \
 		DisplayListRenderer.cpp \
 		Dither.cpp \
@@ -70,7 +71,7 @@
 	LOCAL_CFLAGS += -DUSE_OPENGL_RENDERER -DEGL_EGLEXT_PROTOTYPES -DGL_GLEXT_PROTOTYPES
 	LOCAL_CFLAGS += -Wno-unused-parameter
 	LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-	LOCAL_SHARED_LIBRARIES := liblog libcutils libutils libEGL libGLESv2 libskia libui
+	LOCAL_SHARED_LIBRARIES := liblog libcutils libutils libEGL libGLESv2 libskia libui libgui
 	LOCAL_MODULE := libhwui
 	LOCAL_MODULE_TAGS := optional
 
diff --git a/libs/hwui/DeferredLayerUpdater.cpp b/libs/hwui/DeferredLayerUpdater.cpp
new file mode 100644
index 0000000..ed05d04
--- /dev/null
+++ b/libs/hwui/DeferredLayerUpdater.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2014 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 "DeferredLayerUpdater.h"
+
+#include "OpenGLRenderer.h"
+
+#include "LayerRenderer.h"
+
+namespace android {
+namespace uirenderer {
+
+DeferredLayerUpdater::DeferredLayerUpdater(Layer* layer, OpenGLRenderer* renderer)
+        : mDisplayList(0)
+        , mSurfaceTexture(0)
+        , mTransform(0)
+        , mNeedsGLContextAttach(false)
+        , mUpdateTexImage(false)
+        , mLayer(layer)
+        , mRenderer(renderer)
+        , mCaches(Caches::getInstance()) {
+    mCaches.resourceCache.incrementRefcount(mLayer);
+    mWidth = mLayer->layer.getWidth();
+    mHeight = mLayer->layer.getHeight();
+    mBlend = mLayer->isBlend();
+    mColorFilter = mLayer->getColorFilter();
+    mAlpha = mLayer->getAlpha();
+    mMode = mLayer->getMode();
+    mDirtyRect.setEmpty();
+}
+
+DeferredLayerUpdater::~DeferredLayerUpdater() {
+    setColorFilter(NULL);
+    if (mLayer) {
+        mCaches.resourceCache.decrementRefcount(mLayer);
+    }
+    delete mRenderer;
+}
+
+void DeferredLayerUpdater::setColorFilter(SkColorFilter* colorFilter) {
+    SkRefCnt_SafeAssign(mColorFilter, colorFilter);
+}
+
+void DeferredLayerUpdater::setDisplayList(DisplayList* displayList,
+        int left, int top, int right, int bottom) {
+    mDisplayList = displayList;
+    if (mDirtyRect.isEmpty()) {
+        mDirtyRect.set(left, top, right, bottom);
+    } else {
+        mDirtyRect.unionWith(Rect(left, top, right, bottom));
+    }
+}
+
+bool DeferredLayerUpdater::apply() {
+    bool success = true;
+    // These properties are applied the same to both layer types
+    mLayer->setColorFilter(mColorFilter);
+    mLayer->setAlpha(mAlpha, mMode);
+
+    if (mDisplayList) {
+        if (mWidth != mLayer->layer.getWidth() || mHeight != mLayer->layer.getHeight()) {
+            success = LayerRenderer::resizeLayer(mLayer, mWidth, mHeight);
+        }
+        mLayer->setBlend(mBlend);
+        mLayer->updateDeferred(mRenderer, mDisplayList,
+                mDirtyRect.left, mDirtyRect.top, mDirtyRect.right, mDirtyRect.bottom);
+        mDirtyRect.setEmpty();
+        mDisplayList = 0;
+    } else if (mSurfaceTexture.get()) {
+        if (mNeedsGLContextAttach) {
+            mNeedsGLContextAttach = false;
+            mSurfaceTexture->attachToContext(mLayer->getTexture());
+        }
+        if (mUpdateTexImage) {
+            mUpdateTexImage = false;
+            doUpdateTexImage();
+        }
+        if (mTransform) {
+            mLayer->getTransform().load(*mTransform);
+            setTransform(0);
+        }
+    }
+    return success;
+}
+
+void DeferredLayerUpdater::doUpdateTexImage() {
+    if (mSurfaceTexture->updateTexImage() == NO_ERROR) {
+        float transform[16];
+
+        int64_t frameNumber = mSurfaceTexture->getFrameNumber();
+        // If the GLConsumer queue is in synchronous mode, need to discard all
+        // but latest frame, using the frame number to tell when we no longer
+        // have newer frames to target. Since we can't tell which mode it is in,
+        // do this unconditionally.
+        int dropCounter = 0;
+        while (mSurfaceTexture->updateTexImage() == NO_ERROR) {
+            int64_t newFrameNumber = mSurfaceTexture->getFrameNumber();
+            if (newFrameNumber == frameNumber) break;
+            frameNumber = newFrameNumber;
+            dropCounter++;
+        }
+        #if DEBUG_RENDERER
+        if (dropCounter > 0) {
+            RENDERER_LOGD("Dropped %d frames on texture layer update", dropCounter);
+        }
+        #endif
+        mSurfaceTexture->getTransformMatrix(transform);
+        GLenum renderTarget = mSurfaceTexture->getCurrentTextureTarget();
+
+        LayerRenderer::updateTextureLayer(mLayer, mWidth, mHeight, !mBlend,
+                renderTarget, transform);
+    }
+}
+
+void DeferredLayerUpdater::applyDeferred(DeferredLayerUpdater* deferredApply) {
+    // Default assignment operator doesn't quite work, and fails due to mCaches anyway
+    deferredApply->mWidth = mWidth;
+    deferredApply->mHeight = mHeight;
+    deferredApply->mBlend = mBlend;
+    deferredApply->mAlpha = mAlpha;
+    deferredApply->mMode = mMode;
+    deferredApply->mDirtyRect.set(mDirtyRect);
+    deferredApply->mDisplayList = mDisplayList;
+    deferredApply->mSurfaceTexture = mSurfaceTexture;
+    deferredApply->mNeedsGLContextAttach = mNeedsGLContextAttach;
+    deferredApply->mUpdateTexImage = mUpdateTexImage;
+    deferredApply->setColorFilter(mColorFilter);
+    deferredApply->setTransform(mTransform);
+
+    mDisplayList = 0;
+    mDirtyRect.setEmpty();
+    mTransform = 0;
+    mNeedsGLContextAttach = false;
+    mUpdateTexImage = false;
+}
+
+} /* namespace uirenderer */
+} /* namespace android */
diff --git a/libs/hwui/DeferredLayerUpdater.h b/libs/hwui/DeferredLayerUpdater.h
new file mode 100644
index 0000000..0350eef
--- /dev/null
+++ b/libs/hwui/DeferredLayerUpdater.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2014 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.
+ */
+#ifndef DEFERREDLAYERUPDATE_H_
+#define DEFERREDLAYERUPDATE_H_
+
+#include <cutils/compiler.h>
+#include <gui/GLConsumer.h>
+#include <SkColorFilter.h>
+#include <SkMatrix.h>
+#include <utils/StrongPointer.h>
+
+#include "DisplayList.h"
+#include "Layer.h"
+#include "OpenGLRenderer.h"
+#include "Rect.h"
+
+namespace android {
+namespace uirenderer {
+
+// Container to hold the properties a layer should be set to at the start
+// of a render pass
+class DeferredLayerUpdater {
+public:
+    ANDROID_API DeferredLayerUpdater(Layer* layer, OpenGLRenderer* renderer = 0);
+    ANDROID_API ~DeferredLayerUpdater();
+
+    ANDROID_API bool setSize(uint32_t width, uint32_t height) {
+        if (mWidth != width || mHeight != height) {
+            mWidth = width;
+            mHeight = height;
+            return true;
+        }
+        return false;
+    }
+
+    ANDROID_API bool setBlend(bool blend) {
+        if (blend != mBlend) {
+            mBlend = blend;
+            return true;
+        }
+        return false;
+    }
+
+    ANDROID_API void setSurfaceTexture(const sp<GLConsumer>& texture, bool needsAttach) {
+        if (texture.get() != mSurfaceTexture.get()) {
+            mNeedsGLContextAttach = needsAttach;
+            mSurfaceTexture = texture;
+        }
+    }
+
+    ANDROID_API void updateTexImage() {
+        mUpdateTexImage = true;
+    }
+
+    ANDROID_API void setTransform(const SkMatrix* matrix) {
+        delete mTransform;
+        mTransform = matrix ? new SkMatrix(*matrix) : 0;
+    }
+
+    ANDROID_API void setDisplayList(DisplayList* displayList,
+                int left, int top, int right, int bottom);
+
+    ANDROID_API void setPaint(const SkPaint* paint) {
+        OpenGLRenderer::getAlphaAndModeDirect(paint, &mAlpha, &mMode);
+    }
+
+    ANDROID_API void setColorFilter(SkColorFilter* colorFilter);
+
+    ANDROID_API bool apply();
+    ANDROID_API void applyDeferred(DeferredLayerUpdater* deferredApply);
+
+    ANDROID_API Layer* backingLayer() {
+        return mLayer;
+    }
+
+    ANDROID_API Layer* detachBackingLayer() {
+        Layer* layer = mLayer;
+        mLayer = 0;
+        return layer;
+    }
+
+private:
+    // Generic properties
+    uint32_t mWidth;
+    uint32_t mHeight;
+    bool mBlend;
+    SkColorFilter* mColorFilter;
+    int mAlpha;
+    SkXfermode::Mode mMode;
+
+    // Layer type specific properties
+    // displayList and surfaceTexture are mutually exclusive, only 1 may be set
+    // dirtyRect is only valid if displayList is set
+    DisplayList* mDisplayList;
+    Rect mDirtyRect;
+    sp<GLConsumer> mSurfaceTexture;
+    SkMatrix* mTransform;
+    bool mNeedsGLContextAttach;
+    bool mUpdateTexImage;
+
+    Layer* mLayer;
+    OpenGLRenderer* mRenderer;
+    Caches& mCaches;
+
+    void doUpdateTexImage();
+};
+
+} /* namespace uirenderer */
+} /* namespace android */
+
+#endif /* DEFERREDLAYERUPDATE_H_ */
diff --git a/libs/hwui/LayerRenderer.cpp b/libs/hwui/LayerRenderer.cpp
index 0b38c4d..ea8eb31 100644
--- a/libs/hwui/LayerRenderer.cpp
+++ b/libs/hwui/LayerRenderer.cpp
@@ -184,7 +184,7 @@
 // Layers management
 ///////////////////////////////////////////////////////////////////////////////
 
-Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) {
+Layer* LayerRenderer::createRenderLayer(uint32_t width, uint32_t height) {
     LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height);
 
     Caches& caches = Caches::getInstance();
@@ -221,7 +221,6 @@
     layer->texCoords.set(0.0f, height / float(layer->getHeight()),
             width / float(layer->getWidth()), 0.0f);
     layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
-    layer->setBlend(!isOpaque);
     layer->setColorFilter(NULL);
     layer->setDirty(true);
     layer->region.clear();
@@ -270,13 +269,12 @@
     return true;
 }
 
-Layer* LayerRenderer::createTextureLayer(bool isOpaque) {
+Layer* LayerRenderer::createTextureLayer() {
     LAYER_RENDERER_LOGD("Creating new texture layer");
 
     Layer* layer = new Layer(0, 0);
     layer->setCacheable(false);
     layer->setTextureLayer(true);
-    layer->setBlend(!isOpaque);
     layer->setEmpty(true);
     layer->setFbo(0);
     layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
diff --git a/libs/hwui/LayerRenderer.h b/libs/hwui/LayerRenderer.h
index f24c8d4..84acd44 100644
--- a/libs/hwui/LayerRenderer.h
+++ b/libs/hwui/LayerRenderer.h
@@ -52,8 +52,8 @@
     virtual status_t clear(float left, float top, float right, float bottom, bool opaque);
     virtual void finish();
 
-    ANDROID_API static Layer* createTextureLayer(bool isOpaque);
-    ANDROID_API static Layer* createLayer(uint32_t width, uint32_t height, bool isOpaque = false);
+    ANDROID_API static Layer* createTextureLayer();
+    ANDROID_API static Layer* createRenderLayer(uint32_t width, uint32_t height);
     ANDROID_API static bool resizeLayer(Layer* layer, uint32_t width, uint32_t height);
     ANDROID_API static void updateTextureLayer(Layer* layer, uint32_t width, uint32_t height,
             bool isOpaque, GLenum renderTarget, float* transform);