SkRemote: fix Misc hash function.

src/core/SkRemote.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPath.h"
 #include "SkRect.h"
 #include "SkRemote.h"
@@ skipping 17 matching lines @@
         paint->setDither       (fDither);
     }
 
     static bool operator==(const Misc& a, const Misc& b) {
         return a.fColor         == b.fColor
             && a.fFilterQuality == b.fFilterQuality
             && a.fAntiAlias     == b.fAntiAlias
             && a.fDither        == b.fDither;
     }
 
+    // Misc carries 10 bytes of data in a 12 byte struct, so we need a custom hash.
+    static_assert(sizeof(Misc) > offsetof(Misc, fDither) + sizeof(Misc().fDither), "");
+    struct MiscHash {
+        uint32_t operator()(const Misc& misc) {
+            return SkChecksum::Murmur3(&misc, offsetof(Misc, fDither) + sizeof(Misc().fDither));
+        }
+    };
+
     Stroke Stroke::CreateFrom(const SkPaint& paint) {
         Stroke stroke = {
             paint.getStrokeWidth(),
             paint.getStrokeMiter(),
             paint.getStrokeCap(),
             paint.getStrokeJoin(),
         };
         return stroke;
     }
 
     void Stroke::applyTo(SkPaint* paint) const {
         paint->setStrokeWidth(fWidth);
         paint->setStrokeMiter(fMiter);
         paint->setStrokeCap  (fCap);
         paint->setStrokeJoin (fJoin);
     }
 
     static bool operator==(const Stroke& a, const Stroke& b) {
         return a.fWidth == b.fWidth
             && a.fMiter == b.fMiter
             && a.fCap   == b.fCap
             && a.fJoin  == b.fJoin;
     }
 
+    // The default SkGoodHash works fine for Stroke, as it's dense.
+    static_assert(sizeof(Stroke) == offsetof(Stroke, fJoin) + sizeof(Stroke().fJoin), "");
+
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
 
     class LookupScope {
     public:
         LookupScope(Cache* cache, Encoder* encoder) : fCache(cache), fEncoder(encoder) {}
         ~LookupScope() { for (ID id : fToUndefine) { fEncoder->undefine(id); } }
         void undefineWhenDone(ID id) { fToUndefine.push_back(id); }
 
         template <typename T>
         ID lookup(const T& val) {
@@ skipping 83 matching lines @@
             bool lookup(const Misc& misc, ID* id, LookupScope*) override {
                 return always_cache_helper(misc, &fMisc, &fNextMisc, id);
             }
             bool lookup(const SkPath& path, ID* id, LookupScope*) override {
                 return always_cache_helper(path, &fPath, &fNextPath, id);
             }
             bool lookup(const Stroke& stroke, ID* id, LookupScope*) override {
                 return always_cache_helper(stroke, &fStroke, &fNextStroke, id);
             }
 
-            SkTHashMap<SkMatrix, ID> fMatrix;
-            SkTHashMap<Misc,     ID> fMisc;
-            SkTHashMap<SkPath,   ID> fPath;
-            SkTHashMap<Stroke,   ID> fStroke;
+            SkTHashMap<SkMatrix, ID>           fMatrix;
+            SkTHashMap<Misc,     ID, MiscHash> fMisc;
+            SkTHashMap<SkPath,   ID>           fPath;
+            SkTHashMap<Stroke,   ID>           fStroke;
             ID fNextMatrix,
                fNextMisc,
                fNextPath,
                fNextStroke;
         };
         return new AlwaysCache;
     }
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
 
@@ skipping 144 matching lines @@
     }
     void Server::strokePath(ID path, ID misc, ID stroke) {
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         fMisc  .find(misc  ).applyTo(&paint);
         fStroke.find(stroke).applyTo(&paint);
         fCanvas->drawPath(fPath.find(path), paint);
     }
 
 } // namespace SkRemote