diff --git a/libs/hwui/AmbientShadow.cpp b/libs/hwui/AmbientShadow.cpp
index 75cbfa1..181230a 100644
--- a/libs/hwui/AmbientShadow.cpp
+++ b/libs/hwui/AmbientShadow.cpp
@@ -97,9 +97,9 @@
     // calculate the normal N, which should be perpendicular to the edge of the
     // polygon (represented by the neighbor intersection points) .
     // Shadow's vertices will be generated as : P + N * scale.
-    const Vector2 centroid2d = Vector2(centroid3d.x, centroid3d.y);
+    const Vector2 centroid2d = {centroid3d.x, centroid3d.y};
     for (int rayIndex = 0; rayIndex < rays; rayIndex++) {
-        Vector2 normal(1.0f, 0.0f);
+        Vector2 normal = {1.0f, 0.0f};
         calculateNormal(rays, rayIndex, dir.array(), rayDist, normal);
 
         // The vertex should be start from rayDist[i] then scale the
diff --git a/libs/hwui/LayerRenderer.h b/libs/hwui/LayerRenderer.h
index 9202e49..bf7828c 100644
--- a/libs/hwui/LayerRenderer.h
+++ b/libs/hwui/LayerRenderer.h
@@ -49,7 +49,7 @@
     LayerRenderer(RenderState& renderState, Layer* layer);
     virtual ~LayerRenderer();
 
-    virtual void onViewportInitialized(int width, int height) { /* do nothing */ }
+    virtual void onViewportInitialized() { /* do nothing */ }
     virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque);
     virtual status_t clear(float left, float top, float right, float bottom, bool opaque);
     virtual void finish();
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 4f81066..64df6c8 100755
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -138,7 +138,7 @@
         , mRenderState(renderState)
         , mScissorOptimizationDisabled(false)
         , mCountOverdraw(false)
-        , mLightCenter(FLT_MIN, FLT_MIN, FLT_MIN)
+        , mLightCenter((Vector3){FLT_MIN, FLT_MIN, FLT_MIN})
         , mLightRadius(FLT_MIN)
         , mAmbientShadowAlpha(0)
         , mSpotShadowAlpha(0) {
diff --git a/libs/hwui/PathTessellator.cpp b/libs/hwui/PathTessellator.cpp
index 804ec41..209341c 100644
--- a/libs/hwui/PathTessellator.cpp
+++ b/libs/hwui/PathTessellator.cpp
@@ -90,7 +90,7 @@
  *
  * NOTE: assumes angles between normals 90 degrees or less
  */
-inline static vec2 totalOffsetFromNormals(const vec2& normalA, const vec2& normalB) {
+inline static Vector2 totalOffsetFromNormals(const Vector2& normalA, const Vector2& normalB) {
     return (normalA + normalB) / (1 + fabs(normalA.dot(normalB)));
 }
 
@@ -129,7 +129,7 @@
     float halfStrokeWidth;
     float maxAlpha;
 
-    inline void scaleOffsetForStrokeWidth(vec2& offset) const {
+    inline void scaleOffsetForStrokeWidth(Vector2& offset) const {
         if (halfStrokeWidth == 0.0f) {
             // hairline - compensate for scale
             offset.x *= 0.5f * inverseScaleX;
@@ -143,9 +143,8 @@
      * NOTE: the input will not always be a normal, especially for sharp edges - it should be the
      * result of totalOffsetFromNormals (see documentation there)
      */
-    inline vec2 deriveAAOffset(const vec2& offset) const {
-        return vec2(offset.x * 0.5f * inverseScaleX,
-            offset.y * 0.5f * inverseScaleY);
+    inline Vector2 deriveAAOffset(const Vector2& offset) const {
+        return (Vector2){offset.x * 0.5f * inverseScaleX, offset.y * 0.5f * inverseScaleY};
     }
 
     /**
@@ -208,16 +207,14 @@
     int currentIndex = 0;
     const Vertex* last = &(perimeter[perimeter.size() - 1]);
     const Vertex* current = &(perimeter[0]);
-    vec2 lastNormal(current->y - last->y,
-            last->x - current->x);
+    Vector2 lastNormal = {current->y - last->y, last->x - current->x};
     lastNormal.normalize();
     for (unsigned int i = 0; i < perimeter.size(); i++) {
         const Vertex* next = &(perimeter[i + 1 >= perimeter.size() ? 0 : i + 1]);
-        vec2 nextNormal(next->y - current->y,
-                current->x - next->x);
+        Vector2 nextNormal = {next->y - current->y, current->x - next->x};
         nextNormal.normalize();
 
-        vec2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
+        Vector2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
         paintInfo.scaleOffsetForStrokeWidth(totalOffset);
 
         Vertex::set(&buffer[currentIndex++],
@@ -241,13 +238,14 @@
 }
 
 static inline void storeBeginEnd(const PaintInfo& paintInfo, const Vertex& center,
-        const vec2& normal, Vertex* buffer, int& currentIndex, bool begin) {
-    vec2 strokeOffset = normal;
+        const Vector2& normal, Vertex* buffer, int& currentIndex, bool begin) {
+    Vector2 strokeOffset = normal;
     paintInfo.scaleOffsetForStrokeWidth(strokeOffset);
 
-    vec2 referencePoint(center.x, center.y);
+    Vector2 referencePoint = {center.x, center.y};
     if (paintInfo.cap == SkPaint::kSquare_Cap) {
-        referencePoint += vec2(-strokeOffset.y, strokeOffset.x) * (begin ? -1 : 1);
+        Vector2 rotated = {-strokeOffset.y, strokeOffset.x};
+        referencePoint += rotated * (begin ? -1 : 1);
     }
 
     Vertex::set(&buffer[currentIndex++], referencePoint + strokeOffset);
@@ -288,14 +286,14 @@
             }
 
             beginTheta += dTheta;
-            vec2 beginRadialOffset(cos(beginTheta), sin(beginTheta));
+            Vector2 beginRadialOffset = {cos(beginTheta), sin(beginTheta)};
             paintInfo.scaleOffsetForStrokeWidth(beginRadialOffset);
             Vertex::set(&buffer[capOffset],
                     vertices[0].x + beginRadialOffset.x,
                     vertices[0].y + beginRadialOffset.y);
 
             endTheta += dTheta;
-            vec2 endRadialOffset(cos(endTheta), sin(endTheta));
+            Vector2 endRadialOffset = {cos(endTheta), sin(endTheta)};
             paintInfo.scaleOffsetForStrokeWidth(endRadialOffset);
             Vertex::set(&buffer[allocSize - 1 - capOffset],
                     vertices[lastIndex].x + endRadialOffset.x,
@@ -306,22 +304,20 @@
     int currentIndex = extra;
     const Vertex* last = &(vertices[0]);
     const Vertex* current = &(vertices[1]);
-    vec2 lastNormal(current->y - last->y,
-                last->x - current->x);
+    Vector2 lastNormal = {current->y - last->y, last->x - current->x};
     lastNormal.normalize();
 
     storeBeginEnd(paintInfo, vertices[0], lastNormal, buffer, currentIndex, true);
 
     for (unsigned int i = 1; i < vertices.size() - 1; i++) {
         const Vertex* next = &(vertices[i + 1]);
-        vec2 nextNormal(next->y - current->y,
-                current->x - next->x);
+        Vector2 nextNormal = {next->y - current->y, current->x - next->x};
         nextNormal.normalize();
 
-        vec2 strokeOffset  = totalOffsetFromNormals(lastNormal, nextNormal);
+        Vector2 strokeOffset  = totalOffsetFromNormals(lastNormal, nextNormal);
         paintInfo.scaleOffsetForStrokeWidth(strokeOffset);
 
-        vec2 center(current->x, current->y);
+        Vector2 center = {current->x, current->y};
         Vertex::set(&buffer[currentIndex++], center + strokeOffset);
         Vertex::set(&buffer[currentIndex++], center - strokeOffset);
 
@@ -353,18 +349,16 @@
     int currentIndex = 0;
     const Vertex* last = &(perimeter[perimeter.size() - 1]);
     const Vertex* current = &(perimeter[0]);
-    vec2 lastNormal(current->y - last->y,
-            last->x - current->x);
+    Vector2 lastNormal = {current->y - last->y, last->x - current->x};
     lastNormal.normalize();
     for (unsigned int i = 0; i < perimeter.size(); i++) {
         const Vertex* next = &(perimeter[i + 1 >= perimeter.size() ? 0 : i + 1]);
-        vec2 nextNormal(next->y - current->y,
-                current->x - next->x);
+        Vector2 nextNormal = {next->y - current->y, current->x - next->x};
         nextNormal.normalize();
 
         // AA point offset from original point is that point's normal, such that each side is offset
         // by .5 pixels
-        vec2 totalOffset = paintInfo.deriveAAOffset(totalOffsetFromNormals(lastNormal, nextNormal));
+        Vector2 totalOffset = paintInfo.deriveAAOffset(totalOffsetFromNormals(lastNormal, nextNormal));
 
         AlphaVertex::set(&buffer[currentIndex++],
                 current->x + totalOffset.x,
@@ -407,7 +401,7 @@
  * getStrokeVerticesFromUnclosedVerticesAA() below.
  */
 inline static void storeCapAA(const PaintInfo& paintInfo, const Vector<Vertex>& vertices,
-        AlphaVertex* buffer, bool isFirst, vec2 normal, int offset) {
+        AlphaVertex* buffer, bool isFirst, Vector2 normal, int offset) {
     const int extra = paintInfo.capExtraDivisions();
     const int extraOffset = (extra + 1) / 2;
     const int capIndex = isFirst
@@ -416,27 +410,28 @@
     if (isFirst) normal *= -1;
 
     // TODO: this normal should be scaled by radialScale if extra != 0, see totalOffsetFromNormals()
-    vec2 AAOffset = paintInfo.deriveAAOffset(normal);
+    Vector2 AAOffset = paintInfo.deriveAAOffset(normal);
 
-    vec2 strokeOffset = normal;
+    Vector2 strokeOffset = normal;
     paintInfo.scaleOffsetForStrokeWidth(strokeOffset);
-    vec2 outerOffset = strokeOffset + AAOffset;
-    vec2 innerOffset = strokeOffset - AAOffset;
+    Vector2 outerOffset = strokeOffset + AAOffset;
+    Vector2 innerOffset = strokeOffset - AAOffset;
 
-    vec2 capAAOffset;
+    Vector2 capAAOffset = {0, 0};
     if (paintInfo.cap != SkPaint::kRound_Cap) {
         // if the cap is square or butt, the inside primary cap vertices will be inset in two
         // directions - both normal to the stroke, and parallel to it.
-        capAAOffset = vec2(-AAOffset.y, AAOffset.x);
+        capAAOffset = (Vector2){-AAOffset.y, AAOffset.x};
     }
 
     // determine referencePoint, the center point for the 4 primary cap vertices
     const Vertex* point = isFirst ? vertices.begin() : (vertices.end() - 1);
-    vec2 referencePoint(point->x, point->y);
+    Vector2 referencePoint = {point->x, point->y};
     if (paintInfo.cap == SkPaint::kSquare_Cap) {
         // To account for square cap, move the primary cap vertices (that create the AA edge) by the
         // stroke offset vector (rotated to be parallel to the stroke)
-        referencePoint += vec2(-strokeOffset.y, strokeOffset.x);
+        Vector2 rotated = {-strokeOffset.y, strokeOffset.x};
+        referencePoint += rotated;
     }
 
     AlphaVertex::set(&buffer[capIndex + 0],
@@ -469,7 +464,7 @@
         for (int i = 0; i < extra; i++) {
             theta += dTheta;
 
-            vec2 radialOffset(cos(theta), sin(theta));
+            Vector2 radialOffset = {cos(theta), sin(theta)};
 
             // scale to compensate for pinching at sharp angles, see totalOffsetFromNormals()
             radialOffset *= radialScale;
@@ -592,8 +587,7 @@
 
     const Vertex* last = &(vertices[0]);
     const Vertex* current = &(vertices[1]);
-    vec2 lastNormal(current->y - last->y,
-            last->x - current->x);
+    Vector2 lastNormal = {current->y - last->y, last->x - current->x};
     lastNormal.normalize();
 
     // TODO: use normal from bezier traversal for cap, instead of from vertices
@@ -601,16 +595,15 @@
 
     for (unsigned int i = 1; i < vertices.size() - 1; i++) {
         const Vertex* next = &(vertices[i + 1]);
-        vec2 nextNormal(next->y - current->y,
-                current->x - next->x);
+        Vector2 nextNormal = {next->y - current->y, current->x - next->x};
         nextNormal.normalize();
 
-        vec2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
-        vec2 AAOffset = paintInfo.deriveAAOffset(totalOffset);
+        Vector2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
+        Vector2 AAOffset = paintInfo.deriveAAOffset(totalOffset);
 
-        vec2 innerOffset = totalOffset;
+        Vector2 innerOffset = totalOffset;
         paintInfo.scaleOffsetForStrokeWidth(innerOffset);
-        vec2 outerOffset = innerOffset + AAOffset;
+        Vector2 outerOffset = innerOffset + AAOffset;
         innerOffset -= AAOffset;
 
         AlphaVertex::set(&buffer[currentAAOuterIndex++],
@@ -662,21 +655,19 @@
 
     const Vertex* last = &(perimeter[perimeter.size() - 1]);
     const Vertex* current = &(perimeter[0]);
-    vec2 lastNormal(current->y - last->y,
-            last->x - current->x);
+    Vector2 lastNormal = {current->y - last->y, last->x - current->x};
     lastNormal.normalize();
     for (unsigned int i = 0; i < perimeter.size(); i++) {
         const Vertex* next = &(perimeter[i + 1 >= perimeter.size() ? 0 : i + 1]);
-        vec2 nextNormal(next->y - current->y,
-                current->x - next->x);
+        Vector2 nextNormal = {next->y - current->y, current->x - next->x};
         nextNormal.normalize();
 
-        vec2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
-        vec2 AAOffset = paintInfo.deriveAAOffset(totalOffset);
+        Vector2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
+        Vector2 AAOffset = paintInfo.deriveAAOffset(totalOffset);
 
-        vec2 innerOffset = totalOffset;
+        Vector2 innerOffset = totalOffset;
         paintInfo.scaleOffsetForStrokeWidth(innerOffset);
-        vec2 outerOffset = innerOffset + AAOffset;
+        Vector2 outerOffset = innerOffset + AAOffset;
         innerOffset -= AAOffset;
 
         AlphaVertex::set(&buffer[currentAAOuterIndex++],
diff --git a/libs/hwui/RenderNode.cpp b/libs/hwui/RenderNode.cpp
index 3eb779f..b77b36f 100644
--- a/libs/hwui/RenderNode.cpp
+++ b/libs/hwui/RenderNode.cpp
@@ -836,7 +836,8 @@
             DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();
             const int saveCountOffset = renderer.getSaveCount() - 1;
             const int projectionReceiveIndex = mDisplayListData->projectionReceiveIndex;
-            for (unsigned int i = 0; i < mDisplayListData->displayListOps.size(); i++) {
+            const int size = static_cast<int>(mDisplayListData->displayListOps.size());
+            for (int i = 0; i < size; i++) {
                 DisplayListOp *op = mDisplayListData->displayListOps[i];
 
 #if DEBUG_DISPLAY_LIST
diff --git a/libs/hwui/ShadowTessellator.cpp b/libs/hwui/ShadowTessellator.cpp
index bcfda99..e71439d 100644
--- a/libs/hwui/ShadowTessellator.cpp
+++ b/libs/hwui/ShadowTessellator.cpp
@@ -172,7 +172,8 @@
 
     Vector2 centroid = poly[0];
     if (area != 0) {
-        centroid = Vector2(sumx / (3 * area), sumy / (3 * area));
+        centroid = (Vector2){static_cast<float>(sumx / (3 * area)),
+            static_cast<float>(sumy / (3 * area))};
     } else {
         ALOGW("Area is 0 while computing centroid!");
     }
@@ -212,19 +213,19 @@
     while (SkPath::kDone_Verb != (v = iter.next(pts))) {
             switch (v) {
             case SkPath::kMove_Verb:
-                arrayForDirection.add(Vector2(pts[0].x(), pts[0].y()));
+                arrayForDirection.add((Vector2){pts[0].x(), pts[0].y()});
                 break;
             case SkPath::kLine_Verb:
-                arrayForDirection.add(Vector2(pts[1].x(), pts[1].y()));
+                arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()});
                 break;
             case SkPath::kQuad_Verb:
-                arrayForDirection.add(Vector2(pts[1].x(), pts[1].y()));
-                arrayForDirection.add(Vector2(pts[2].x(), pts[2].y()));
+                arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()});
+                arrayForDirection.add((Vector2){pts[2].x(), pts[2].y()});
                 break;
             case SkPath::kCubic_Verb:
-                arrayForDirection.add(Vector2(pts[1].x(), pts[1].y()));
-                arrayForDirection.add(Vector2(pts[2].x(), pts[2].y()));
-                arrayForDirection.add(Vector2(pts[3].x(), pts[3].y()));
+                arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()});
+                arrayForDirection.add((Vector2){pts[2].x(), pts[2].y()});
+                arrayForDirection.add((Vector2){pts[3].x(), pts[3].y()});
                 break;
             default:
                 break;
diff --git a/libs/hwui/SpotShadow.cpp b/libs/hwui/SpotShadow.cpp
index 8a5e722..8c3077b 100644
--- a/libs/hwui/SpotShadow.cpp
+++ b/libs/hwui/SpotShadow.cpp
@@ -218,7 +218,7 @@
 
     // Since neither polygon fully contain the other one, we need to add all the
     // intersection points.
-    Vector2 intersection;
+    Vector2 intersection = {0, 0};
     for (int i = 0; i < poly2Length; i++) {
         for (int j = 0; j < poly1Length; j++) {
             int poly2LineStart = i;
@@ -250,7 +250,7 @@
     }
 
     // Sort the result polygon around the center.
-    Vector2 center(0.0f, 0.0f);
+    Vector2 center = {0.0f, 0.0f};
     for (int i = 0; i < count; i++) {
         center += poly[i];
     }
@@ -557,7 +557,7 @@
             float x = lightPoly[j].x - ratioZ * (lightPoly[j].x - poly[i].x);
             float y = lightPoly[j].y - ratioZ * (lightPoly[j].y - poly[i].y);
 
-            Vector2 newPoint = Vector2(x, y);
+            Vector2 newPoint = {x, y};
             shadowRegion[k] = newPoint;
             outline[m] = newPoint;
 
diff --git a/libs/hwui/TessellationCache.cpp b/libs/hwui/TessellationCache.cpp
index 343f1aa..c5fc21f 100644
--- a/libs/hwui/TessellationCache.cpp
+++ b/libs/hwui/TessellationCache.cpp
@@ -125,7 +125,7 @@
     }
 };
 
-struct TessellationCache::Buffer {
+class TessellationCache::Buffer {
 public:
     Buffer(const sp<Task<VertexBuffer*> >& task)
             : mTask(task)
@@ -236,7 +236,7 @@
     float maxZ = -FLT_MAX;
     for (int i = 0; i < casterVertexCount; i++) {
         const Vertex& point2d = casterVertices2d[i];
-        casterPolygon[i] = Vector3(point2d.x, point2d.y, 0);
+        casterPolygon[i] = (Vector3){point2d.x, point2d.y, 0};
         mapPointFakeZ(casterPolygon[i], casterTransformXY, casterTransformZ);
         minZ = fmin(minZ, casterPolygon[i].z);
         maxZ = fmax(maxZ, casterPolygon[i].z);
@@ -246,7 +246,7 @@
     Vector2 centroid =  ShadowTessellator::centroid2d(
             reinterpret_cast<const Vector2*>(casterVertices2d.array()),
             casterVertexCount);
-    Vector3 centroid3d(centroid.x, centroid.y, 0);
+    Vector3 centroid3d = {centroid.x, centroid.y, 0};
     mapPointFakeZ(centroid3d, casterTransformXY, casterTransformZ);
 
     // if the caster intersects the z=0 plane, lift it in Z so it doesn't
diff --git a/libs/hwui/Vector.h b/libs/hwui/Vector.h
index c61cb61..2a9f01c 100644
--- a/libs/hwui/Vector.h
+++ b/libs/hwui/Vector.h
@@ -24,18 +24,11 @@
 // Classes
 ///////////////////////////////////////////////////////////////////////////////
 
+// MUST BE A POD - this means no ctor or dtor!
 struct Vector2 {
     float x;
     float y;
 
-    Vector2() :
-        x(0.0f), y(0.0f) {
-    }
-
-    Vector2(float px, float py) :
-        x(px), y(py) {
-    }
-
     float lengthSquared() const {
         return x * x + y * y;
     }
@@ -75,19 +68,19 @@
     }
 
     Vector2 operator+(const Vector2& v) const {
-        return Vector2(x + v.x, y + v.y);
+        return (Vector2){x + v.x, y + v.y};
     }
 
     Vector2 operator-(const Vector2& v) const {
-        return Vector2(x - v.x, y - v.y);
+        return (Vector2){x - v.x, y - v.y};
     }
 
     Vector2 operator/(float s) const {
-        return Vector2(x / s, y / s);
+        return (Vector2){x / s, y / s};
     }
 
     Vector2 operator*(float s) const {
-        return Vector2(x * s, y * s);
+        return (Vector2){x * s, y * s};
     }
 
     void normalize() {
@@ -97,7 +90,7 @@
     }
 
     Vector2 copyNormalized() const {
-        Vector2 v(x, y);
+        Vector2 v = {x, y};
         v.normalize();
         return v;
     }
@@ -111,31 +104,18 @@
     }
 }; // class Vector2
 
+// MUST BE A POD - this means no ctor or dtor!
 class Vector3 {
 public:
     float x;
     float y;
     float z;
 
-    Vector3() :
-        x(0.0f), y(0.0f), z(0.0f) {
-    }
-
-    Vector3(float px, float py, float pz) :
-        x(px), y(py), z(pz) {
-    }
-
     void dump() {
         ALOGD("Vector3[%.2f, %.2f, %.2f]", x, y, z);
     }
 };
 
-///////////////////////////////////////////////////////////////////////////////
-// Types
-///////////////////////////////////////////////////////////////////////////////
-
-typedef Vector2 vec2;
-
 }; // namespace uirenderer
 }; // namespace android
 
diff --git a/libs/hwui/Vertex.h b/libs/hwui/Vertex.h
index 5d7a199..4ff0b18 100644
--- a/libs/hwui/Vertex.h
+++ b/libs/hwui/Vertex.h
@@ -43,7 +43,7 @@
         vertex[0].y = y;
     }
 
-    static inline void set(Vertex* vertex, vec2 val) {
+    static inline void set(Vertex* vertex, Vector2 val) {
         set(vertex, val.x, val.y);
     }
 
diff --git a/libs/hwui/utils/MathUtils.h b/libs/hwui/utils/MathUtils.h
index 65f1663..2dfe9c6 100644
--- a/libs/hwui/utils/MathUtils.h
+++ b/libs/hwui/utils/MathUtils.h
@@ -19,19 +19,19 @@
 namespace android {
 namespace uirenderer {
 
+#define NON_ZERO_EPSILON (0.001f)
+
 class MathUtils {
-private:
-    static const float gNonZeroEpsilon = 0.001f;
 public:
     /**
      * Check for floats that are close enough to zero.
      */
     inline static bool isZero(float value) {
-        return (value >= -gNonZeroEpsilon) && (value <= gNonZeroEpsilon);
+        return (value >= -NON_ZERO_EPSILON) && (value <= NON_ZERO_EPSILON);
     }
 
     inline static bool isPositive(float value) {
-        return value >= gNonZeroEpsilon;
+        return value >= NON_ZERO_EPSILON;
     }
 
     inline static bool areEqual(float valueA, float valueB) {