Use sk_careful_memcpy when writing optional conic weights for GrShape path data key.

src/gpu/GrShape.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrShape.h"
 
 GrShape& GrShape::operator=(const GrShape& that) {
@@ skipping 71 matching lines @@
     const int conicWeightCnt = SkPathPriv::ConicWeightCnt(path);
 
     GR_STATIC_ASSERT(sizeof(SkPoint) == 2 * sizeof(uint32_t));
     GR_STATIC_ASSERT(sizeof(SkScalar) == sizeof(uint32_t));
     // 2 is for the verb cnt and a fill type. Each verb is a byte but we'll pad the verb data out to
     // a uint32_t length.
     return 2 + (SkAlign4(verbCnt) >> 2) + 2 * pointCnt + conicWeightCnt;
 }
 
 // Writes the path data key into the passed pointer.
-static void write_path_key_from(const SkPath& path, uint32_t* origKey) {
+static void write_path_key_from_data(const SkPath& path, uint32_t* origKey) {
     uint32_t* key = origKey;
     // The check below should take care of negative values casted positive.
     const int verbCnt = path.countVerbs();
     const int pointCnt = path.countPoints();
     const int conicWeightCnt = SkPathPriv::ConicWeightCnt(path);
     SkASSERT(verbCnt <= GrShape::kMaxKeyFromDataVerbCnt);
     SkASSERT(pointCnt && verbCnt);
     *key++ = path.getFillType();
     *key++ = verbCnt;
     memcpy(key, SkPathPriv::VerbData(path), verbCnt * sizeof(uint8_t));
     int verbKeySize = SkAlign4(verbCnt);
     // pad out to uint32_t alignment using value that will stand out when debugging.
     uint8_t* pad = reinterpret_cast<uint8_t*>(key)+ verbCnt;
     memset(pad, 0xDE, verbKeySize - verbCnt);
     key += verbKeySize >> 2;
 
     memcpy(key, SkPathPriv::PointData(path), sizeof(SkPoint) * pointCnt);
     GR_STATIC_ASSERT(sizeof(SkPoint) == 2 * sizeof(uint32_t));
     key += 2 * pointCnt;
-    memcpy(key, SkPathPriv::ConicWeightData(path), sizeof(SkScalar) * conicWeightCnt);
+    sk_careful_memcpy(key, SkPathPriv::ConicWeightData(path), sizeof(SkScalar) * conicWeightCnt);
     GR_STATIC_ASSERT(sizeof(SkScalar) == sizeof(uint32_t));
     SkDEBUGCODE(key += conicWeightCnt);
     SkASSERT(key - origKey == path_key_from_data_size(path));
 }
 
 int GrShape::unstyledKeySize() const {
     if (fInheritedKey.count()) {
         return fInheritedKey.count();
     }
     switch (fType) {
@@ skipping 44 matching lines @@
                 SkASSERT(fRRectData.fStart < 8);
                 break;
             case Type::kLine:
                 memcpy(key, fLineData.fPts, 2 * sizeof(SkPoint));
                 key += 4;
                 *key++ = fLineData.fInverted ? 1 : 0;
                 break;
             case Type::kPath: {
                 int dataKeySize = path_key_from_data_size(fPathData.fPath);
                 if (dataKeySize >= 0) {
-                    write_path_key_from(fPathData.fPath, key);
+                    write_path_key_from_data(fPathData.fPath, key);
                     return;
                 }
                 SkASSERT(fPathData.fGenID);
                 *key++ = fPathData.fGenID;
                 // We could canonicalize the fill rule for paths that don't differentiate between
                 // even/odd or winding fill (e.g. convex).
                 *key++ = this->path().getFillType();
                 break;
             }
         }
@@ skipping 343 matching lines @@
             fStyle = GrStyle::SimpleFill();
             return;
         }
     }
     // Only path effects could care about the order of the points. Otherwise canonicalize
     // the point order.
     if (pts[1].fY < pts[0].fY || (pts[1].fY == pts[0].fY && pts[1].fX < pts[0].fX)) {
         SkTSwap(pts[0], pts[1]);
     }
 }