diff --git a/libs/hwui/Android.mk b/libs/hwui/Android.mk
index d0b9d82..3e590a9 100644
--- a/libs/hwui/Android.mk
+++ b/libs/hwui/Android.mk
@@ -6,6 +6,8 @@
 # getConfig in external/skia/include/core/SkBitmap.h is deprecated.
 # Allow Gnu extension: in-class initializer of static 'const float' member.
 LOCAL_CLANG_CFLAGS += \
+    -Wno-unused-parameter \
+    -Wno-deprecated-declarations \
     -Wno-gnu-static-float-init
 
 # Only build libhwui when USE_OPENGL_RENDERER is
diff --git a/libs/hwui/AnimationContext.cpp b/libs/hwui/AnimationContext.cpp
index d2152ca..a20bdae 100644
--- a/libs/hwui/AnimationContext.cpp
+++ b/libs/hwui/AnimationContext.cpp
@@ -54,7 +54,7 @@
     handle->insertAfter(&mNextFrameAnimations);
 }
 
-void AnimationContext::startFrame(TreeInfo::TraversalMode /* mode */) {
+void AnimationContext::startFrame(TreeInfo::TraversalMode mode) {
     LOG_ALWAYS_FATAL_IF(mCurrentFrameAnimations.mNextHandle,
             "Missed running animations last frame!");
     AnimationHandle* head = mNextFrameAnimations.mNextHandle;
diff --git a/libs/hwui/Animator.cpp b/libs/hwui/Animator.cpp
index 71b7476..8bf2107 100644
--- a/libs/hwui/Animator.cpp
+++ b/libs/hwui/Animator.cpp
@@ -245,11 +245,11 @@
         , mProperty(property) {
 }
 
-float CanvasPropertyPrimitiveAnimator::getValue(RenderNode* /* target */) const {
+float CanvasPropertyPrimitiveAnimator::getValue(RenderNode* target) const {
     return mProperty->value;
 }
 
-void CanvasPropertyPrimitiveAnimator::setValue(RenderNode* /* target */, float value) {
+void CanvasPropertyPrimitiveAnimator::setValue(RenderNode* target, float value) {
     mProperty->value = value;
 }
 
@@ -268,7 +268,7 @@
         , mField(field) {
 }
 
-float CanvasPropertyPaintAnimator::getValue(RenderNode* /* target */) const {
+float CanvasPropertyPaintAnimator::getValue(RenderNode* target) const {
     switch (mField) {
     case STROKE_WIDTH:
         return mProperty->value.getStrokeWidth();
@@ -284,7 +284,7 @@
     return static_cast<uint8_t>( c < 0 ? 0 : c > 255 ? 255 : c );
 }
 
-void CanvasPropertyPaintAnimator::setValue(RenderNode* /* target */, float value) {
+void CanvasPropertyPaintAnimator::setValue(RenderNode* target, float value) {
     switch (mField) {
     case STROKE_WIDTH:
         mProperty->value.setStrokeWidth(value);
diff --git a/libs/hwui/Caches.h b/libs/hwui/Caches.h
index 17c717f1..7aa628c 100644
--- a/libs/hwui/Caches.h
+++ b/libs/hwui/Caches.h
@@ -385,13 +385,13 @@
 
     bool bindIndicesBufferInternal(const GLuint buffer);
 
-    static void eventMarkNull(GLsizei /* length */, const GLchar* /* marker */) { }
-    static void startMarkNull(GLsizei /* length */, const GLchar* /* marker */) { }
+    static void eventMarkNull(GLsizei length, const GLchar* marker) { }
+    static void startMarkNull(GLsizei length, const GLchar* marker) { }
     static void endMarkNull() { }
 
-    static void setLabelNull(GLenum /* type */, uint /* object */, GLsizei /* length */,
-            const char* /* label */) { }
-    static void getLabelNull(GLenum /* type */, uint /* object */, GLsizei /* bufferSize */,
+    static void setLabelNull(GLenum type, uint object, GLsizei length,
+            const char* label) { }
+    static void getLabelNull(GLenum type, uint object, GLsizei bufferSize,
             GLsizei* length, char* label) {
         if (length) *length = 0;
         if (label) *label = '\0';
diff --git a/libs/hwui/DeferredDisplayList.cpp b/libs/hwui/DeferredDisplayList.cpp
index 6703f1d..fbe2d39 100644
--- a/libs/hwui/DeferredDisplayList.cpp
+++ b/libs/hwui/DeferredDisplayList.cpp
@@ -55,7 +55,7 @@
     virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) = 0;
     virtual ~Batch() {}
     virtual bool purelyDrawBatch() { return false; }
-    virtual bool coversBounds(const Rect& /* bounds */) { return false; }
+    virtual bool coversBounds(const Rect& bounds) { return false; }
 };
 
 class DrawBatch : public Batch {
@@ -91,7 +91,7 @@
         return false;
     }
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int /* index */) {
+    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("%d  replaying DrawBatch %p, with %d ops (batch id %x, merge id %p)",
                 index, this, mOps.size(), getBatchId(), getMergeId());
 
@@ -269,7 +269,7 @@
         if (newClipSideFlags & kClipSide_Bottom) mClipRect.bottom = state->mClip.bottom;
     }
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int /* index */) {
+    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("%d  replaying MergingDrawBatch %p, with %d ops,"
                 " clip flags %x (batch id %x, merge id %p)",
                 index, this, mOps.size(), mClipSideFlags, getBatchId(), getMergeId());
@@ -313,7 +313,7 @@
     // creates a single operation batch
     StateOpBatch(const StateOp* op, const DeferredDisplayState* state) : mOp(op), mState(state) {}
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& /* dirty */, int /* index */) {
+    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("replaying state op batch %p", this);
         renderer.restoreDisplayState(*mState);
 
@@ -332,10 +332,10 @@
 
 class RestoreToCountBatch : public Batch {
 public:
-    RestoreToCountBatch(const StateOp* /* op */, const DeferredDisplayState* state,
-                        int restoreCount) : mState(state), mRestoreCount(restoreCount) {}
+    RestoreToCountBatch(const StateOp* op, const DeferredDisplayState* state, int restoreCount) :
+            mState(state), mRestoreCount(restoreCount) {}
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& /* dirty */, int /* index */) {
+    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("batch %p restoring to count %d", this, mRestoreCount);
 
         renderer.restoreDisplayState(*mState);
diff --git a/libs/hwui/DisplayListOp.h b/libs/hwui/DisplayListOp.h
index e55d750..cb3ef9b 100644
--- a/libs/hwui/DisplayListOp.h
+++ b/libs/hwui/DisplayListOp.h
@@ -63,7 +63,7 @@
     // These objects should always be allocated with a LinearAllocator, and never destroyed/deleted.
     // standard new() intentionally not implemented, and delete/deconstructor should never be used.
     virtual ~DisplayListOp() { CRASH(); }
-    static void operator delete(void* /* ptr */) { CRASH(); }
+    static void operator delete(void* ptr) { CRASH(); }
     /** static void* operator new(size_t size); PURPOSELY OMITTED **/
     static void* operator new(size_t size, LinearAllocator& allocator) {
         return allocator.alloc(size);
@@ -93,8 +93,8 @@
 
     virtual ~StateOp() {}
 
-    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
-            bool /* useQuickReject */) {
+    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+            bool useQuickReject) {
         // default behavior only affects immediate, deferrable state, issue directly to renderer
         applyState(deferStruct.mRenderer, saveCount);
     }
@@ -103,8 +103,8 @@
      * State operations are applied directly to the renderer, but can cause the deferred drawing op
      * list to flush
      */
-    virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int /* level */,
-            bool /* useQuickReject */) {
+    virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
+            bool useQuickReject) {
         applyState(replayStruct.mRenderer, saveCount);
     }
 
@@ -117,7 +117,7 @@
     DrawOp(const SkPaint* paint)
             : mPaint(paint), mQuickRejected(false) {}
 
-    virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
+    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
             bool useQuickReject) {
         if (mQuickRejected && CC_LIKELY(useQuickReject)) {
             return;
@@ -126,7 +126,7 @@
         deferStruct.mDeferredList.addDrawOp(deferStruct.mRenderer, this);
     }
 
-    virtual void replay(ReplayStateStruct& replayStruct, int /* saveCount */, int /* level */,
+    virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
             bool useQuickReject) {
         if (mQuickRejected && CC_LIKELY(useQuickReject)) {
             return;
@@ -145,7 +145,7 @@
      * reducing which operations are tagged as mergeable.
      */
     virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
-            const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
+            const Vector<OpStatePair>& ops, const Rect& bounds) {
         status_t status = DrawGlInfo::kStatusDone;
         for (unsigned int i = 0; i < ops.size(); i++) {
             renderer.restoreDisplayState(*(ops[i].state), true);
@@ -164,15 +164,15 @@
      *
      * if a subclass can set deferInfo.mergeable to true, it should implement multiDraw()
      */
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& /* deferInfo */,
-            const DeferredDisplayState& /* state */) {}
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+            const DeferredDisplayState& state) {}
 
     /**
      * Query the conservative, local bounds (unmapped) bounds of the op.
      *
      * returns true if bounds exist
      */
-    virtual bool getLocalBounds(Rect& /* localBounds */) {
+    virtual bool getLocalBounds(Rect& localBounds) {
         return false;
     }
 
@@ -282,17 +282,17 @@
     SaveOp(int flags)
             : mFlags(flags) {}
 
-    virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
-            bool /* useQuickReject */) {
+    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+            bool useQuickReject) {
         int newSaveCount = deferStruct.mRenderer.save(mFlags);
         deferStruct.mDeferredList.addSave(deferStruct.mRenderer, this, newSaveCount);
     }
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.save(mFlags);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Save flags %x", mFlags);
     }
 
@@ -308,8 +308,8 @@
     RestoreToCountOp(int count)
             : mCount(count) {}
 
-    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
-            bool /* useQuickReject */) {
+    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+            bool useQuickReject) {
         deferStruct.mDeferredList.addRestoreToCount(deferStruct.mRenderer,
                 this, saveCount + mCount);
         deferStruct.mRenderer.restoreToCount(saveCount + mCount);
@@ -319,7 +319,7 @@
         renderer.restoreToCount(saveCount + mCount);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Restore to count %d", mCount);
     }
 
@@ -346,8 +346,8 @@
             , mConvexMask(NULL)
     {}
 
-    virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
-            bool /* useQuickReject */) {
+    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+            bool useQuickReject) {
         // NOTE: don't bother with actual saveLayer, instead issuing it at flush time
         int newSaveCount = deferStruct.mRenderer.getSaveCount();
         deferStruct.mDeferredList.addSaveLayer(deferStruct.mRenderer, this, newSaveCount);
@@ -358,12 +358,12 @@
                 mPaint, mFlags);
     }
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.saveLayer(mArea.left, mArea.top, mArea.right, mArea.bottom,
                 mPaint, mFlags, mConvexMask);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("SaveLayer%s of area " RECT_STRING,
                 (isSaveLayerAlpha() ? "Alpha" : ""),RECT_ARGS(mArea));
     }
@@ -399,11 +399,11 @@
     TranslateOp(float dx, float dy)
             : mDx(dx), mDy(dy) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.translate(mDx, mDy);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Translate by %f %f", mDx, mDy);
     }
 
@@ -419,11 +419,11 @@
     RotateOp(float degrees)
             : mDegrees(degrees) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.rotate(mDegrees);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Rotate by %f degrees", mDegrees);
     }
 
@@ -438,11 +438,11 @@
     ScaleOp(float sx, float sy)
             : mSx(sx), mSy(sy) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.scale(mSx, mSy);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Scale by %f %f", mSx, mSy);
     }
 
@@ -458,11 +458,11 @@
     SkewOp(float sx, float sy)
             : mSx(sx), mSy(sy) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.skew(mSx, mSy);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Skew by %f %f", mSx, mSy);
     }
 
@@ -478,11 +478,11 @@
     SetMatrixOp(const SkMatrix& matrix)
             : mMatrix(matrix) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.setMatrix(mMatrix);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         if (mMatrix.isIdentity()) {
             OP_LOGS("SetMatrix (reset)");
         } else {
@@ -501,11 +501,11 @@
     ConcatMatrixOp(const SkMatrix& matrix)
             : mMatrix(matrix) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.concatMatrix(mMatrix);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("ConcatMatrix " SK_MATRIX_STRING, SK_MATRIX_ARGS(&mMatrix));
     }
 
@@ -519,8 +519,8 @@
 public:
     ClipOp(SkRegion::Op op) : mOp(op) {}
 
-    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
-            bool /* useQuickReject */) {
+    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+            bool useQuickReject) {
         // NOTE: must defer op BEFORE applying state, since it may read clip
         deferStruct.mDeferredList.addClip(deferStruct.mRenderer, this);
 
@@ -543,11 +543,11 @@
     ClipRectOp(float left, float top, float right, float bottom, SkRegion::Op op)
             : ClipOp(op), mArea(left, top, right, bottom) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.clipRect(mArea.left, mArea.top, mArea.right, mArea.bottom, mOp);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("ClipRect " RECT_STRING, RECT_ARGS(mArea));
     }
 
@@ -565,11 +565,11 @@
     ClipPathOp(const SkPath* path, SkRegion::Op op)
             : ClipOp(op), mPath(path) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.clipPath(mPath, mOp);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         SkRect bounds = mPath->getBounds();
         OP_LOG("ClipPath bounds " RECT_STRING,
                 bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
@@ -586,11 +586,11 @@
     ClipRegionOp(const SkRegion* region, SkRegion::Op op)
             : ClipOp(op), mRegion(region) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.clipRegion(mRegion, mOp);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         SkIRect bounds = mRegion->getBounds();
         OP_LOG("ClipRegion bounds %d %d %d %d",
                 bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
@@ -604,11 +604,11 @@
 
 class ResetPaintFilterOp : public StateOp {
 public:
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.resetPaintFilter();
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOGS("ResetPaintFilter");
     }
 
@@ -620,11 +620,11 @@
     SetupPaintFilterOp(int clearBits, int setBits)
             : mClearBits(clearBits), mSetBits(setBits) {}
 
-    virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+    virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
         renderer.setupPaintFilter(mClearBits, mSetBits);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("SetupPaintFilter, clear %#x, set %#x", mClearBits, mSetBits);
     }
 
@@ -652,7 +652,7 @@
         }
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawBitmap(mBitmap, getPaint(renderer));
     }
 
@@ -675,7 +675,7 @@
      * for each bitmap in the batch. This method is also responsible for dirtying
      * the current layer, if any.
      */
-    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
+    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
             const Vector<OpStatePair>& ops, const Rect& bounds) {
         const DeferredDisplayState& firstState = *(ops[0].state);
         renderer.restoreDisplayState(firstState, true); // restore all but the clip
@@ -716,13 +716,13 @@
                 pureTranslate, bounds, mPaint);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw bitmap %p at %f %f", mBitmap, mLocalBounds.left, mLocalBounds.top);
     }
 
     virtual const char* name() { return "DrawBitmap"; }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
             const DeferredDisplayState& state) {
         deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
         deferInfo.mergeId = getAtlasEntry() ?
@@ -755,21 +755,21 @@
             : DrawBoundedOp(dstLeft, dstTop, dstRight, dstBottom, paint),
             mBitmap(bitmap), mSrc(srcLeft, srcTop, srcRight, srcBottom) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawBitmap(mBitmap, mSrc.left, mSrc.top, mSrc.right, mSrc.bottom,
                 mLocalBounds.left, mLocalBounds.top, mLocalBounds.right, mLocalBounds.bottom,
                 getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw bitmap %p src=" RECT_STRING ", dst=" RECT_STRING,
                 mBitmap, RECT_ARGS(mSrc), RECT_ARGS(mLocalBounds));
     }
 
     virtual const char* name() { return "DrawBitmapRect"; }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+            const DeferredDisplayState& state) {
         deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
     }
 
@@ -783,18 +783,18 @@
     DrawBitmapDataOp(const SkBitmap* bitmap, const SkPaint* paint)
             : DrawBitmapOp(bitmap, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawBitmapData(mBitmap, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw bitmap %p", mBitmap);
     }
 
     virtual const char* name() { return "DrawBitmapData"; }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+            const DeferredDisplayState& state) {
         deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
     }
 };
@@ -807,19 +807,19 @@
             mBitmap(bitmap), mMeshWidth(meshWidth), mMeshHeight(meshHeight),
             mVertices(vertices), mColors(colors) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawBitmapMesh(mBitmap, mMeshWidth, mMeshHeight,
                 mVertices, mColors, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw bitmap %p mesh %d x %d", mBitmap, mMeshWidth, mMeshHeight);
     }
 
     virtual const char* name() { return "DrawBitmapMesh"; }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+            const DeferredDisplayState& state) {
         deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
     }
 
@@ -868,8 +868,8 @@
      * and transforming the vertices of each 9-patch in the batch. This method
      * is also responsible for dirtying the current layer, if any.
      */
-    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
-            const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
+    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+            const Vector<OpStatePair>& ops, const Rect& bounds) {
         const DeferredDisplayState& firstState = *(ops[0].state);
         renderer.restoreDisplayState(firstState, true); // restore all but the clip
 
@@ -942,7 +942,7 @@
                 &vertices[0], indexCount, getPaint(renderer));
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         // We're not calling the public variant of drawPatch() here
         // This method won't perform the quickReject() since we've already done it at this point
         return renderer.drawPatch(mBitmap, getMesh(renderer), getAtlasEntry(),
@@ -950,13 +950,13 @@
                 getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw patch " RECT_STRING, RECT_ARGS(mLocalBounds));
     }
 
     virtual const char* name() { return "DrawPatch"; }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
             const DeferredDisplayState& state) {
         deferInfo.batchId = DeferredDisplayList::kOpBatch_Patch;
         deferInfo.mergeId = getAtlasEntry() ? (mergeid_t) mEntry->getMergeId() : (mergeid_t) mBitmap;
@@ -982,11 +982,11 @@
     DrawColorOp(int color, SkXfermode::Mode mode)
             : DrawOp(NULL), mColor(color), mMode(mode) {};
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawColor(mColor, mMode);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw color %#x, mode %d", mColor, mMode);
     }
 
@@ -1012,8 +1012,8 @@
         return true;
     }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+            const DeferredDisplayState& state) {
         if (mPaint->getPathEffect()) {
             deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture;
         } else {
@@ -1029,12 +1029,12 @@
     DrawRectOp(float left, float top, float right, float bottom, const SkPaint* paint)
             : DrawStrokableOp(left, top, right, bottom, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawRect(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Rect " RECT_STRING, RECT_ARGS(mLocalBounds));
     }
 
@@ -1054,18 +1054,18 @@
             : DrawBoundedOp(rects, count, paint),
             mRects(rects), mCount(count) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawRects(mRects, mCount, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Rects count %d", mCount);
     }
 
     virtual const char* name() { return "DrawRects"; }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+            const DeferredDisplayState& state) {
         deferInfo.batchId = DeferredDisplayList::kOpBatch_Vertices;
     }
 
@@ -1080,12 +1080,12 @@
             float rx, float ry, const SkPaint* paint)
             : DrawStrokableOp(left, top, right, bottom, paint), mRx(rx), mRy(ry) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawRoundRect(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom, mRx, mRy, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw RoundRect " RECT_STRING ", rx %f, ry %f", RECT_ARGS(mLocalBounds), mRx, mRy);
     }
 
@@ -1112,12 +1112,12 @@
             : DrawOp(paint), mLeft(left), mTop(top), mRight(right), mBottom(bottom),
             mRx(rx), mRy(ry) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawRoundRect(*mLeft, *mTop, *mRight, *mBottom,
                 *mRx, *mRy, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw RoundRect Props " RECT_STRING ", rx %f, ry %f",
                 *mLeft, *mTop, *mRight, *mBottom, *mRx, *mRy);
     }
@@ -1139,11 +1139,11 @@
             : DrawStrokableOp(x - radius, y - radius, x + radius, y + radius, paint),
             mX(x), mY(y), mRadius(radius) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawCircle(mX, mY, mRadius, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Circle x %f, y %f, r %f", mX, mY, mRadius);
     }
 
@@ -1160,11 +1160,11 @@
     DrawCirclePropsOp(float* x, float* y, float* radius, const SkPaint* paint)
             : DrawOp(paint), mX(x), mY(y), mRadius(radius) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawCircle(*mX, *mY, *mRadius, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Circle Props x %p, y %p, r %p", mX, mY, mRadius);
     }
 
@@ -1181,12 +1181,12 @@
     DrawOvalOp(float left, float top, float right, float bottom, const SkPaint* paint)
             : DrawStrokableOp(left, top, right, bottom, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawOval(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Oval " RECT_STRING, RECT_ARGS(mLocalBounds));
     }
 
@@ -1200,13 +1200,13 @@
             : DrawStrokableOp(left, top, right, bottom, paint),
             mStartAngle(startAngle), mSweepAngle(sweepAngle), mUseCenter(useCenter) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawArc(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom,
                 mStartAngle, mSweepAngle, mUseCenter, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Arc " RECT_STRING ", start %f, sweep %f, useCenter %d",
                 RECT_ARGS(mLocalBounds), mStartAngle, mSweepAngle, mUseCenter);
     }
@@ -1231,19 +1231,19 @@
         mLocalBounds.set(left, top, left + width, top + height);
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawPath(mPath, getPaint(renderer));
     }
 
     virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+            const DeferredDisplayState& state) {
         const SkPaint* paint = getPaint(renderer);
         renderer.getCaches().pathCache.precache(mPath, paint);
 
         deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture;
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Path %p in " RECT_STRING, mPath, RECT_ARGS(mLocalBounds));
     }
 
@@ -1261,18 +1261,18 @@
         mLocalBounds.outset(strokeWidthOutset());
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawLines(mPoints, mCount, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Lines count %d", mCount);
     }
 
     virtual const char* name() { return "DrawLines"; }
 
-    virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+            const DeferredDisplayState& state) {
         deferInfo.batchId = mPaint->isAntiAlias() ?
                 DeferredDisplayList::kOpBatch_AlphaVertices :
                 DeferredDisplayList::kOpBatch_Vertices;
@@ -1288,11 +1288,11 @@
     DrawPointsOp(const float* points, int count, const SkPaint* paint)
             : DrawLinesOp(points, count, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawPoints(mPoints, mCount, getPaint(renderer));
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Points count %d", mCount);
     }
 
@@ -1304,7 +1304,7 @@
     DrawSomeTextOp(const char* text, int bytesCount, int count, const SkPaint* paint)
             : DrawOp(paint), mText(text), mBytesCount(bytesCount), mCount(count) {};
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw some text, %d bytes", mBytesCount);
     }
 
@@ -1313,7 +1313,7 @@
     }
 
     virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
-            const DeferredDisplayState& /* state */) {
+            const DeferredDisplayState& state) {
         const SkPaint* paint = getPaint(renderer);
         FontRenderer& fontRenderer = renderer.getCaches().fontRenderer->getFontRenderer(paint);
         fontRenderer.precache(paint, mText, mCount, SkMatrix::I());
@@ -1338,7 +1338,7 @@
         /* TODO: inherit from DrawBounded and init mLocalBounds */
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawTextOnPath(mText, mBytesCount, mCount, mPath,
                 mHOffset, mVOffset, getPaint(renderer));
     }
@@ -1359,7 +1359,7 @@
         /* TODO: inherit from DrawBounded and init mLocalBounds */
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawPosText(mText, mBytesCount, mCount, mPositions, getPaint(renderer));
     }
 
@@ -1403,15 +1403,15 @@
                 && OpenGLRenderer::getXfermodeDirect(mPaint) == SkXfermode::kSrcOver_Mode;
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         Rect bounds;
         getLocalBounds(bounds);
         return renderer.drawText(mText, mBytesCount, mCount, mX, mY,
                 mPositions, getPaint(renderer), mTotalAdvance, bounds);
     }
 
-    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
-            const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
+    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+            const Vector<OpStatePair>& ops, const Rect& bounds) {
         status_t status = DrawGlInfo::kStatusDone;
         for (unsigned int i = 0; i < ops.size(); i++) {
             const DeferredDisplayState& state = *(ops[i].state);
@@ -1428,7 +1428,7 @@
         return status;
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Text of count %d, bytes %d", mCount, mBytesCount);
     }
 
@@ -1461,7 +1461,7 @@
         return ret;
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Functor %p", mFunctor);
     }
 
@@ -1479,21 +1479,21 @@
             : DrawBoundedOp(0, 0, renderNode->getWidth(), renderNode->getHeight(), 0),
             mRenderNode(renderNode), mFlags(flags), mTransformFromParent(transformFromParent) {}
 
-    virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int level,
-            bool /* useQuickReject */) {
+    virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+            bool useQuickReject) {
         if (mRenderNode->isRenderable() && !mSkipInOrderDraw) {
             mRenderNode->defer(deferStruct, level + 1);
         }
     }
 
-    virtual void replay(ReplayStateStruct& replayStruct, int /* saveCount */, int level,
-            bool /* useQuickReject */) {
+    virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
+            bool useQuickReject) {
         if (mRenderNode->isRenderable() && !mSkipInOrderDraw) {
             mRenderNode->replay(replayStruct, level + 1);
         }
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& /* renderer */, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         LOG_ALWAYS_FATAL("should not be called, because replay() is overridden");
         return 0;
     }
@@ -1547,14 +1547,14 @@
         , mCasterOutline(casterOutline) {
     }
 
-    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& /* deferInfo */,
+    virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
             const DeferredDisplayState& state) {
         renderer.getCaches().tessellationCache.precacheShadows(&state.mMatrix,
                 renderer.getLocalClipBounds(), isCasterOpaque(), mCasterOutline,
                 &mTransformXY, &mTransformZ, renderer.getLightCenter(), renderer.getLightRadius());
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         TessellationCache::vertexBuffer_pair_t buffers;
         Matrix4 drawTransform(*(renderer.currentTransform()));
         renderer.getCaches().tessellationCache.getShadowBuffers(&drawTransform,
@@ -1565,7 +1565,7 @@
         return renderer.drawShadow(mCasterAlpha, buffers.first, buffers.second);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOGS("DrawShadow");
     }
 
@@ -1585,11 +1585,11 @@
     DrawLayerOp(Layer* layer, float x, float y)
             : DrawOp(NULL), mLayer(layer), mX(x), mY(y) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         return renderer.drawLayer(mLayer, mX, mY);
     }
 
-    virtual void output(int level, uint32_t /* logFlags */) const {
+    virtual void output(int level, uint32_t logFlags) const {
         OP_LOG("Draw Layer %p at %f %f", mLayer, mX, mY);
     }
 
diff --git a/libs/hwui/DisplayListRenderer.cpp b/libs/hwui/DisplayListRenderer.cpp
index 35e47c0..1f70921 100644
--- a/libs/hwui/DisplayListRenderer.cpp
+++ b/libs/hwui/DisplayListRenderer.cpp
@@ -59,8 +59,8 @@
     return data;
 }
 
-status_t DisplayListRenderer::prepareDirty(float /* left */, float /* top */,
-        float /* right */, float /* bottom */, bool opaque) {
+status_t DisplayListRenderer::prepareDirty(float left, float top,
+        float right, float bottom, bool opaque) {
 
     LOG_ALWAYS_FATAL_IF(mDisplayListData,
             "prepareDirty called a second time during a recording!");
@@ -86,7 +86,7 @@
 void DisplayListRenderer::resume() {
 }
 
-status_t DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& /* dirty */) {
+status_t DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) {
     // Ignore dirty during recording, it matters only when we replay
     addDrawOp(new (alloc()) DrawFunctorOp(functor));
     mDisplayListData->functors.add(functor);
@@ -177,8 +177,7 @@
     return StatefulBaseRenderer::clipRegion(region, op);
 }
 
-status_t DisplayListRenderer::drawRenderNode(RenderNode* renderNode, Rect& /* dirty */,
-                                             int32_t flags) {
+status_t DisplayListRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t flags) {
     LOG_ALWAYS_FATAL_IF(!renderNode, "missing rendernode");
 
     // dirty is an out parameter and should not be recorded,
@@ -392,7 +391,7 @@
 
 status_t DisplayListRenderer::drawText(const char* text, int bytesCount, int count,
         float x, float y, const float* positions, const SkPaint* paint,
-        float totalAdvance, const Rect& bounds, DrawOpMode /* drawOpMode */) {
+        float totalAdvance, const Rect& bounds, DrawOpMode drawOpMode) {
 
     if (!text || count <= 0 || paintWillNotDrawText(*paint)) return DrawGlInfo::kStatusDone;
 
diff --git a/libs/hwui/FontRenderer.cpp b/libs/hwui/FontRenderer.cpp
index 27ee0dc..5b5b098 100644
--- a/libs/hwui/FontRenderer.cpp
+++ b/libs/hwui/FontRenderer.cpp
@@ -47,7 +47,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 // TextSetupFunctor
 ///////////////////////////////////////////////////////////////////////////////
-status_t TextSetupFunctor::operator ()(int /* what */, void* data) {
+status_t TextSetupFunctor::operator ()(int what, void* data) {
     Data* typedData = reinterpret_cast<Data*>(data);
     GLenum glyphFormat = typedData ? typedData->glyphFormat : GL_ALPHA;
 
diff --git a/libs/hwui/GammaFontRenderer.h b/libs/hwui/GammaFontRenderer.h
index 3abbad0..46cfd04 100644
--- a/libs/hwui/GammaFontRenderer.h
+++ b/libs/hwui/GammaFontRenderer.h
@@ -70,7 +70,7 @@
         }
     }
 
-    FontRenderer& getFontRenderer(const SkPaint* /* paint */) {
+    FontRenderer& getFontRenderer(const SkPaint* paint) {
         if (!mRenderer) {
             mRenderer = new FontRenderer;
         }
@@ -81,7 +81,7 @@
         return 1;
     }
 
-    uint32_t getFontRendererSize(uint32_t /* fontRenderer */, GLenum format) const {
+    uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const {
         return mRenderer ? mRenderer->getCacheSize(format) : 0;
     }
 
@@ -116,7 +116,7 @@
         }
     }
 
-    FontRenderer& getFontRenderer(const SkPaint* /* paint */) {
+    FontRenderer& getFontRenderer(const SkPaint* paint) {
         if (!mRenderer) {
             mRenderer = new FontRenderer;
             mRenderer->setGammaTable(&mGammaTable[0]);
@@ -128,14 +128,14 @@
         return 1;
     }
 
-    uint32_t getFontRendererSize(uint32_t /* fontRenderer */, GLenum format) const {
+    uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const {
         return mRenderer ? mRenderer->getCacheSize(format) : 0;
     }
 
-    void describe(ProgramDescription& /* description */, const SkPaint* /* paint */) const {
+    void describe(ProgramDescription& description, const SkPaint* paint) const {
     }
 
-    void setupProgram(ProgramDescription& /* description */, Program* /* program */) const {
+    void setupProgram(ProgramDescription& description, Program* program) const {
     }
 
     void endPrecaching();
@@ -171,10 +171,10 @@
         return renderer->getCacheSize(format);
     }
 
-    void describe(ProgramDescription& /* description */, const SkPaint* /* paint */) const {
+    void describe(ProgramDescription& description, const SkPaint* paint) const {
     }
 
-    void setupProgram(ProgramDescription& /* description */, Program* /* program */) const {
+    void setupProgram(ProgramDescription& description, Program* program) const {
     }
 
     void endPrecaching();
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 488ae91..40a58f2 100755
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -348,7 +348,7 @@
     dirtyClip();
 }
 
-status_t OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& /* dirty */) {
+status_t OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& dirty) {
     if (currentSnapshot()->isIgnored()) return DrawGlInfo::kStatusDone;
 
     Rect clip(*currentClipRect());
@@ -401,8 +401,6 @@
     va_end(ap);
 
     eventMark(buf);
-#else
-    (void)fmt;
 #endif
 }
 
@@ -1089,7 +1087,7 @@
     }
 
 protected:
-    virtual void shadeSpan(int /* x */, int /* y */, SkPMColor[], int /* count */) {
+    virtual void shadeSpan(int x, int y, SkPMColor[], int count) {
         LOG_ALWAYS_FATAL("LayerShader should never be drawn with raster backend.");
     }
 
diff --git a/libs/hwui/PathCache.cpp b/libs/hwui/PathCache.cpp
index 9ffe2d8..a3d7019 100644
--- a/libs/hwui/PathCache.cpp
+++ b/libs/hwui/PathCache.cpp
@@ -196,7 +196,7 @@
 // Callbacks
 ///////////////////////////////////////////////////////////////////////////////
 
-void PathCache::operator()(PathDescription& /* entry */, PathTexture*& texture) {
+void PathCache::operator()(PathDescription& entry, PathTexture*& texture) {
     removeTexture(texture);
 }
 
diff --git a/libs/hwui/Program.h b/libs/hwui/Program.h
index 7ea5376..56773f4 100644
--- a/libs/hwui/Program.h
+++ b/libs/hwui/Program.h
@@ -285,8 +285,6 @@
         programid k = key();
         PROGRAM_LOGD("%s (key = 0x%.8x%.8x)", message, uint32_t(k >> 32),
                 uint32_t(k & 0xffffffff));
-#else
-        (void)message;
 #endif
     }
 
diff --git a/libs/hwui/ProgramCache.cpp b/libs/hwui/ProgramCache.cpp
index a591150..06353c0 100644
--- a/libs/hwui/ProgramCache.cpp
+++ b/libs/hwui/ProgramCache.cpp
@@ -455,7 +455,7 @@
 // Program generation
 ///////////////////////////////////////////////////////////////////////////////
 
-Program* ProgramCache::generateProgram(const ProgramDescription& description, programid /* key */) {
+Program* ProgramCache::generateProgram(const ProgramDescription& description, programid key) {
     String8 vertexShader = generateVertexShader(description);
     String8 fragmentShader = generateFragmentShader(description);
 
diff --git a/libs/hwui/RenderNode.cpp b/libs/hwui/RenderNode.cpp
index 28394e5..22808e2 100644
--- a/libs/hwui/RenderNode.cpp
+++ b/libs/hwui/RenderNode.cpp
@@ -274,7 +274,7 @@
     }
 }
 
-void RenderNode::applyLayerPropertiesToLayer(TreeInfo& /* info */) {
+void RenderNode::applyLayerPropertiesToLayer(TreeInfo& info) {
     if (CC_LIKELY(!mLayer)) return;
 
     const LayerProperties& props = properties().layerProperties();
@@ -567,7 +567,7 @@
         operation->defer(mDeferStruct, saveCount, mLevel, clipToBounds);
     }
     inline LinearAllocator& allocator() { return *(mDeferStruct.mAllocator); }
-    inline void startMark(const char* /* name */) {} // do nothing
+    inline void startMark(const char* name) {} // do nothing
     inline void endMark() {}
     inline int level() { return mLevel; }
     inline int replayFlags() { return mDeferStruct.mReplayFlags; }
diff --git a/libs/hwui/RenderState.h b/libs/hwui/RenderState.h
index cd3d60d..cbe7cfc 100644
--- a/libs/hwui/RenderState.h
+++ b/libs/hwui/RenderState.h
@@ -52,13 +52,13 @@
 
     void debugOverdraw(bool enable, bool clear);
 
-    void registerLayer(const Layer* /* layer */) {
+    void registerLayer(const Layer* layer) {
         /*
         AutoMutex _lock(mLayerLock);
         mActiveLayers.insert(layer);
         */
     }
-    void unregisterLayer(const Layer* /* layer */) {
+    void unregisterLayer(const Layer* layer) {
         /*
         AutoMutex _lock(mLayerLock);
         mActiveLayers.erase(layer);
diff --git a/libs/hwui/SkiaShader.cpp b/libs/hwui/SkiaShader.cpp
index 76a70c2..c672bc4 100644
--- a/libs/hwui/SkiaShader.cpp
+++ b/libs/hwui/SkiaShader.cpp
@@ -163,7 +163,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkiaLayerShader::describe(Caches*, ProgramDescription& description,
-        const Extensions&, const SkShader& /* shader */) {
+        const Extensions&, const SkShader& shader) {
     description.hasBitmap = true;
 }
 
@@ -339,7 +339,7 @@
 }
 
 void SkiaGradientShader::describe(Caches*, ProgramDescription& description,
-        const Extensions& /* extensions */, const SkShader& shader) {
+        const Extensions& extensions, const SkShader& shader) {
     SkShader::GradientInfo gradInfo;
     gradInfo.fColorCount = 0;
     gradInfo.fColors = NULL;
diff --git a/libs/hwui/SkiaShader.h b/libs/hwui/SkiaShader.h
index c0a00ee..034c3f6 100644
--- a/libs/hwui/SkiaShader.h
+++ b/libs/hwui/SkiaShader.h
@@ -57,13 +57,12 @@
 
 class InvalidSkiaShader {
 public:
-    static void describe(Caches* /* caches */, ProgramDescription& /* description */,
-            const Extensions& /* extensions */, const SkShader& /* shader */) {
+    static void describe(Caches* caches, ProgramDescription& description,
+            const Extensions& extensions, const SkShader& shader) {
         // This shader is unsupported. Skip it.
     }
-    static void setupProgram(Caches* /* caches */, const mat4& /* modelViewMatrix */,
-            GLuint* /* textureUnit */, const Extensions& /* extensions */,
-            const SkShader& /* shader */) {
+    static void setupProgram(Caches* caches, const mat4& modelViewMatrix,
+            GLuint* textureUnit, const Extensions& extensions, const SkShader& shader) {
         // This shader is unsupported. Skip it.
     }
 
diff --git a/libs/hwui/SpotShadow.cpp b/libs/hwui/SpotShadow.cpp
index 576ba0e..dbedf94 100644
--- a/libs/hwui/SpotShadow.cpp
+++ b/libs/hwui/SpotShadow.cpp
@@ -912,8 +912,6 @@
         angleDataList[i].set(currentAngle, isPenumbra, i);
 #if DEBUG_SHADOW
         ALOGD("%s AngleList i %d %f", name, i, currentAngle);
-#else
-        (void)name;
 #endif
     }
     return maxAngleIndex;
@@ -943,8 +941,6 @@
         if (currentAngle < nextAngle) {
 #if DEBUG_SHADOW
             ALOGE("%s, is not CW, at index %d", name, currentIndex);
-#else
-            (void)name;
 #endif
             return false;
         }
@@ -1382,7 +1378,7 @@
 /**
  * Generate a triangle strip given two convex polygon
 **/
-void SpotShadow::generateTriangleStrip(bool isCasterOpaque, float /* shadowStrengthScale */,
+void SpotShadow::generateTriangleStrip(bool isCasterOpaque, float shadowStrengthScale,
         Vector2* penumbra, int penumbraLength, Vector2* umbra, int umbraLength,
         const Vector3* poly, int polyLength, VertexBuffer& shadowTriangleStrip,
         const Vector2& centroid) {
diff --git a/libs/hwui/StatefulBaseRenderer.h b/libs/hwui/StatefulBaseRenderer.h
index a8e4f88..745e48a 100644
--- a/libs/hwui/StatefulBaseRenderer.h
+++ b/libs/hwui/StatefulBaseRenderer.h
@@ -129,8 +129,7 @@
      *
      * Subclasses can override this method to handle layer restoration
      */
-    virtual void onSnapshotRestored(const Snapshot& /* removed */,
-                                    const Snapshot& /* restored */) {};
+    virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {};
 
     virtual void onViewportInitialized() {};
 
diff --git a/libs/hwui/TessellationCache.cpp b/libs/hwui/TessellationCache.cpp
index 35ec5e9..1e38f9e 100644
--- a/libs/hwui/TessellationCache.cpp
+++ b/libs/hwui/TessellationCache.cpp
@@ -365,7 +365,7 @@
 // Callbacks
 ///////////////////////////////////////////////////////////////////////////////
 
-void TessellationCache::BufferRemovedListener::operator()(Description& /* description */,
+void TessellationCache::BufferRemovedListener::operator()(Description& description,
         Buffer*& buffer) {
     delete buffer;
 }
diff --git a/libs/hwui/TessellationCache.h b/libs/hwui/TessellationCache.h
index a05c690..688a699 100644
--- a/libs/hwui/TessellationCache.h
+++ b/libs/hwui/TessellationCache.h
@@ -178,8 +178,7 @@
     // holds a pointer, and implicit strong ref to each shadow task of the frame
     LruCache<ShadowDescription, Task<vertexBuffer_pair_t*>*> mShadowCache;
     class BufferPairRemovedListener : public OnEntryRemoved<ShadowDescription, Task<vertexBuffer_pair_t*>*> {
-        void operator()(ShadowDescription& /* description */,
-                        Task<vertexBuffer_pair_t*>*& bufferPairTask) {
+        void operator()(ShadowDescription& description, Task<vertexBuffer_pair_t*>*& bufferPairTask) {
             bufferPairTask->decStrong(NULL);
         }
     };
diff --git a/libs/hwui/font/Font.cpp b/libs/hwui/font/Font.cpp
index edfa1ec..bf55558 100644
--- a/libs/hwui/font/Font.cpp
+++ b/libs/hwui/font/Font.cpp
@@ -139,8 +139,7 @@
 }
 
 void Font::measureCachedGlyph(CachedGlyphInfo *glyph, int x, int y,
-        uint8_t* /* bitmap */, uint32_t /* bitmapW */, uint32_t /* bitmapH */, Rect* bounds,
-        const float* /* pos */) {
+        uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) {
     int width = (int) glyph->mBitmapWidth;
     int height = (int) glyph->mBitmapHeight;
 
@@ -162,8 +161,7 @@
 }
 
 void Font::drawCachedGlyph(CachedGlyphInfo* glyph, int x, int y,
-        uint8_t* /* bitmap */, uint32_t /* bitmapW */, uint32_t /* bitmapH */, Rect* /* bounds */,
-        const float* /* pos */) {
+        uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) {
     float width = (float) glyph->mBitmapWidth;
     float height = (float) glyph->mBitmapHeight;
 
@@ -182,8 +180,7 @@
 }
 
 void Font::drawCachedGlyphTransformed(CachedGlyphInfo* glyph, int x, int y,
-        uint8_t* /* bitmap */, uint32_t /* bitmapW */, uint32_t /* bitmapH */, Rect* /* bounds */,
-        const float* /* pos */) {
+        uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) {
     float width = (float) glyph->mBitmapWidth;
     float height = (float) glyph->mBitmapHeight;
 
@@ -213,8 +210,7 @@
 }
 
 void Font::drawCachedGlyphBitmap(CachedGlyphInfo* glyph, int x, int y, uint8_t* bitmap,
-        uint32_t bitmapWidth, uint32_t /* bitmapHeight */, Rect* /* bounds */,
-        const float* /* pos */) {
+        uint32_t bitmapWidth, uint32_t bitmapHeight, Rect* bounds, const float* pos) {
     int dstX = x + glyph->mBitmapLeft;
     int dstY = y + glyph->mBitmapTop;
 
@@ -431,7 +427,7 @@
     }
 }
 
-void Font::updateGlyphCache(const SkPaint* /* paint */, const SkGlyph& skiaGlyph,
+void Font::updateGlyphCache(const SkPaint* paint, const SkGlyph& skiaGlyph,
         SkGlyphCache* skiaGlyphCache, CachedGlyphInfo* glyph, bool precaching) {
     glyph->mAdvanceX = skiaGlyph.fAdvanceX;
     glyph->mAdvanceY = skiaGlyph.fAdvanceY;
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index ab6588a..b50a433 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -115,13 +115,13 @@
     setSurface(window);
 }
 
-void CanvasContext::pauseSurface(ANativeWindow* /* window */) {
+void CanvasContext::pauseSurface(ANativeWindow* window) {
     stopDrawing();
 }
 
 // TODO: don't pass viewport size, it's automatic via EGL
-void CanvasContext::setup(int /* width */, int /* height */, const Vector3& lightCenter,
-        float lightRadius, uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
+void CanvasContext::setup(int width, int height, const Vector3& lightCenter, float lightRadius,
+        uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
     if (!mCanvas) return;
     mCanvas->initLight(lightCenter, lightRadius, ambientShadowAlpha, spotShadowAlpha);
 }
diff --git a/libs/hwui/renderthread/RenderProxy.cpp b/libs/hwui/renderthread/RenderProxy.cpp
index 8fd39cd..c6ea82b 100644
--- a/libs/hwui/renderthread/RenderProxy.cpp
+++ b/libs/hwui/renderthread/RenderProxy.cpp
@@ -344,16 +344,14 @@
     }
 }
 
-template <typename T>
-void UNUSED(T) {}
-
-
 CREATE_BRIDGE0(fence) {
     // Intentionally empty
-    UNUSED(args);
     return NULL;
 }
 
+template <typename T>
+void UNUSED(T t) {}
+
 void RenderProxy::fence() {
     SETUP_TASK(fence);
     UNUSED(args);
diff --git a/libs/hwui/renderthread/RenderThread.cpp b/libs/hwui/renderthread/RenderThread.cpp
index 1be4a97..403e164 100644
--- a/libs/hwui/renderthread/RenderThread.cpp
+++ b/libs/hwui/renderthread/RenderThread.cpp
@@ -171,7 +171,7 @@
     mRenderState = new RenderState();
 }
 
-int RenderThread::displayEventReceiverCallback(int /* fd */, int events, void* data) {
+int RenderThread::displayEventReceiverCallback(int fd, int events, void* data) {
     if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
         ALOGE("Display event receiver pipe was closed or an error occurred.  "
                 "events=0x%x", events);