Remove SK_OFFSETOF from SkTypes, clean up offsetof usage.

src/core/SkMatrix.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkFloatBits.h"
 #include "SkRSXform.h"
@@ skipping 1568 matching lines @@
         return -1;
     }
 }
 
 bool SkMatrix::getMinMaxScales(SkScalar scaleFactors[2]) const {
     return get_scale_factor<kBoth_MinMaxOrBoth>(this->getType(), fMat, scaleFactors);
 }
 
 namespace {
 
-struct PODMatrix {
+// SkMatrix is C++11 POD (trivial and standard-layout), but not aggregate (it has private fields).
+struct AggregateMatrix {
     SkScalar matrix[9];
     uint32_t typemask;
 
     const SkMatrix& asSkMatrix() const { return *reinterpret_cast<const SkMatrix*>(this); }
 };
-static_assert(sizeof(PODMatrix) == sizeof(SkMatrix), "PODMatrixSizeMismatch");
+static_assert(sizeof(AggregateMatrix) == sizeof(SkMatrix), "AggregateMatrix size mismatch.");
 
 }  // namespace
 
 const SkMatrix& SkMatrix::I() {
-    static_assert(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   "BadfMat");
-    static_assert(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), "BadfTypeMask");
+    static_assert(offsetof(SkMatrix,fMat)      == offsetof(AggregateMatrix,matrix),   "fMat");
+    static_assert(offsetof(SkMatrix,fTypeMask) == offsetof(AggregateMatrix,typemask), "fTypeMask");
 
-    static const PODMatrix identity = { {SK_Scalar1, 0, 0,
-                                         0, SK_Scalar1, 0,
-                                         0, 0, SK_Scalar1 },
-                                       kIdentity_Mask | kRectStaysRect_Mask};
+    static const AggregateMatrix identity = { {SK_Scalar1, 0, 0,
+                                               0, SK_Scalar1, 0,
+                                               0, 0, SK_Scalar1 },
+                                             kIdentity_Mask | kRectStaysRect_Mask};
     SkASSERT(identity.asSkMatrix().isIdentity());
     return identity.asSkMatrix();
 }
 
 const SkMatrix& SkMatrix::InvalidMatrix() {
-    static_assert(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   "BadfMat");
-    static_assert(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), "BadfTypeMask");
+    static_assert(offsetof(SkMatrix,fMat)      == offsetof(AggregateMatrix,matrix),   "fMat");
+    static_assert(offsetof(SkMatrix,fTypeMask) == offsetof(AggregateMatrix,typemask), "fTypeMask");
 
-    static const PODMatrix invalid =
+    static const AggregateMatrix invalid =
         { {SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
            SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
            SK_ScalarMax, SK_ScalarMax, SK_ScalarMax },
          kTranslate_Mask | kScale_Mask | kAffine_Mask | kPerspective_Mask };
     return invalid.asSkMatrix();
 }
 
 bool SkMatrix::decomposeScale(SkSize* scale, SkMatrix* remaining) const {
     if (this->hasPerspective()) {
         return false;
@@ skipping 224 matching lines @@
     const SkScalar m11 = m00;
     const SkScalar m12 = fTy;
 
     quad[0].set(m02, m12);
     quad[1].set(m00 * width + m02, m10 * width + m12);
     quad[2].set(m00 * width + m01 * height + m02, m10 * width + m11 * height + m12);
     quad[3].set(m01 * height + m02, m11 * height + m12);
 #endif
 }