Clean up SkTLogic.

src/core/SkRecord.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
@@ skipping 116 matching lines @@
     // We store the types of each of the pointers alongside the pointer.
     // The cost to append a T to this structure is 8 + sizeof(T) bytes.
 
     // A mutator that can be used with replace to destroy canvas commands.
     struct Destroyer {
         template <typename T>
         void operator()(T* record) { record->~T(); }
     };
 
     template <typename T>
-    SK_WHEN(SkTIsEmpty<T>, T*) allocCommand() {
+    SK_WHEN(skstd::is_empty<T>, T*) allocCommand() {
         static T singleton = {};
         return &singleton;
     }
 
     template <typename T>
-    SK_WHEN(!SkTIsEmpty<T>, T*) allocCommand() { return this->alloc<T>(); }
+    SK_WHEN(!skstd::is_empty<T>, T*) allocCommand() { return this->alloc<T>(); }
 
     void grow();
 
     // A typed pointer to some bytes in fAlloc.  visit() and mutate() allow polymorphic dispatch.
     struct Record {
         // On 32-bit machines we store type in 4 bytes, followed by a pointer.  Simple.
         // On 64-bit machines we store a pointer with the type slotted into two top (unused) bytes.
         // FWIW, SkRecords::Type is tiny.  It can easily fit in one byte.
         uint64_t fTypeAndPtr;
         static const int kTypeShift = sizeof(void*) == 4 ? 32 : 48;
@@ skipping 35 matching lines @@
     int fCount, fReserved;
     SkAutoSTMalloc<kInlineRecords, Record> fRecords;
 
     // fAlloc needs to be a data structure which can append variable length data in contiguous
     // chunks, returning a stable handle to that data for later retrieval.
     SkVarAlloc fAlloc;
     char fInlineAlloc[1 << kInlineAllocLgBytes];
 };
 
 #endif//SkRecord_DEFINED