SkPDF: cache metrics once.

include/private/SkTHash.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTHash_DEFINED
 #define SkTHash_DEFINED
 
@@ skipping 30 matching lines @@
     // !!!!!!!!!!!!!!!!!                 CAUTION                   !!!!!!!!!!!!!!!!!
     // set(), find() and foreach() all allow mutable access to table entries.
     // If you change an entry so that it no longer has the same key, all hell
     // will break loose.  Do not do that!
     //
     // Please prefer to use SkTHashMap or SkTHashSet, which do not have this danger.
 
     // The pointers returned by set() and find() are valid only until the next call to set().
     // The pointers you receive in foreach() are only valid for its duration.
 
-    // Copy val into the hash table, returning a pointer to the copy now in the table.
+    // Move val into the hash table, returning a pointer to the copy now in the table.
     // If there already is an entry in the table with the same key, we overwrite it.
-    T* set(const T& val) {
+    T* set(T val) {
         if (4 * (fCount+fRemoved) >= 3 * fCapacity) {
             this->resize(fCapacity > 0 ? fCapacity * 2 : 4);
         }
-        return this->uncheckedSet(val);
+        return this->uncheckedSet(std::move(val));
     }
 
+
     // If there is an entry in the table with this key, return a pointer to it.  If not, NULL.
     T* find(const K& key) const {
         uint32_t hash = Hash(key);
         int index = hash & (fCapacity-1);
         for (int n = 0; n < fCapacity; n++) {
             Slot& s = fSlots[index];
             if (s.empty()) {
                 return NULL;
             }
             if (!s.removed() && hash == s.hash && key == Traits::GetKey(s.val)) {
@@ skipping 39 matching lines @@
     template <typename Fn>  // f(T) or f(const T&)
     void foreach(Fn&& fn) const {
         for (int i = 0; i < fCapacity; i++) {
             if (!fSlots[i].empty() && !fSlots[i].removed()) {
                 fn(fSlots[i].val);
             }
         }
     }
 
 private:
-    T* uncheckedSet(const T& val) {
+    T* uncheckedSet(T val) {
         const K& key = Traits::GetKey(val);
         uint32_t hash = Hash(key);
         int index = hash & (fCapacity-1);
         for (int n = 0; n < fCapacity; n++) {
             Slot& s = fSlots[index];
             if (s.empty() || s.removed()) {
                 // New entry.
                 if (s.removed()) {
                     fRemoved--;
                 }
-                s.val  = val;
+                s.val  = std::move(val);
                 s.hash = hash;
                 fCount++;
                 return &s.val;
             }
             if (hash == s.hash && key == Traits::GetKey(s.val)) {
                 // Overwrite previous entry.
                 // Note: this triggers extra copies when adding the same value repeatedly.
-                s.val = val;
+                s.val = std::move(val);
                 return &s.val;
             }
             index = this->next(index, n);
         }
         SkASSERT(false);
         return NULL;
     }
 
     void resize(int capacity) {
         int oldCapacity = fCapacity;
         SkDEBUGCODE(int oldCount = fCount);
 
         fCount = fRemoved = 0;
         fCapacity = capacity;
         SkAutoTArray<Slot> oldSlots(capacity);
         oldSlots.swap(fSlots);
 
         for (int i = 0; i < oldCapacity; i++) {
             const Slot& s = oldSlots[i];
             if (!s.empty() && !s.removed()) {
-                this->uncheckedSet(s.val);
+                this->uncheckedSet(std::move(s.val));
             }
         }
         SkASSERT(fCount == oldCount);
     }
 
     int next(int index, int n) const {
         // A valid strategy explores all slots in [0, fCapacity) as n walks from 0 to fCapacity-1.
         // Both of these strategies are valid:
         //return (index + 0 + 1) & (fCapacity-1);      // Linear probing.
         return (index + n + 1) & (fCapacity-1);        // Quadratic probing.
@@ skipping 32 matching lines @@
     // How many key/value pairs are in the table?
     int count() const { return fTable.count(); }
 
     // Approximately how many bytes of memory do we use beyond sizeof(*this)?
     size_t approxBytesUsed() const { return fTable.approxBytesUsed(); }
 
     // N.B. The pointers returned by set() and find() are valid only until the next call to set().
 
     // Set key to val in the table, replacing any previous value with the same key.
     // We copy both key and val, and return a pointer to the value copy now in the table.
-    V* set(const K& key, const V& val) {
-        Pair in = { key, val };
-        Pair* out = fTable.set(in);
+    V* set(const K& key, V val) {
+        Pair* out = fTable.set(Pair{ key, std::move(val) });
         return &out->val;
     }
 
     // If there is key/value entry in the table with this key, return a pointer to the value.
     // If not, return NULL.
     V* find(const K& key) const {
         if (Pair* p = fTable.find(key)) {
             return &p->val;
         }
         return NULL;
@@ skipping 67 matching lines @@
 
 private:
     struct Traits {
         static const T& GetKey(const T& item) { return item; }
         static uint32_t Hash(const T& item) { return HashT()(item); }
     };
     SkTHashTable<T, T, Traits> fTable;
 };
 
 #endif//SkTHash_DEFINED