Add approxBytesUsed to hashes.

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 17 matching lines @@
 
     // Clear the table.
     void reset() {
         this->~SkTHashTable();
         SkNEW_PLACEMENT(this, SkTHashTable);
     }
 
     // How many entries are in the table?
     int count() const { return fCount; }
 
+    // Approximately how many bytes of memory do we use beyond sizeof(*this)?
+    size_t approxBytesUsed() const { return fCapacity * sizeof(Slot); }
+
     // !!!!!!!!!!!!!!!!!                 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.
 
@@ skipping 144 matching lines @@
 class SkTHashMap : SkNoncopyable {
 public:
     SkTHashMap() {}
 
     // Clear the map.
     void reset() { fTable.reset(); }
 
     // 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);
         return &out->val;
     }
 
@@ skipping 40 matching lines @@
 class SkTHashSet : SkNoncopyable {
 public:
     SkTHashSet() {}
 
     // Clear the set.
     void reset() { fTable.reset(); }
 
     // How many items are in the set?
     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(); }
+
     // Copy an item into the set.
     void add(const T& item) { fTable.set(item); }
 
     // Is this item in the set?
     bool contains(const T& item) const { return SkToBool(this->find(item)); }
 
     // If an item equal to this is in the set, return a pointer to it, otherwise null.
     // This pointer remains valid until the next call to add().
     const T* find(const T& item) const { return fTable.find(item); }
 
@@ skipping 11 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