remove SkInstCnt

tests/LListTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "SkInstCnt.h"
 #include "SkRandom.h"
 #include "SkTInternalLList.h"
 #include "SkTLList.h"
 #include "Test.h"
 
 class ListElement {
 public:
     ListElement(int id) : fID(id) {
     }
     bool operator== (const ListElement& other) { return fID == other.fID; }
 
-#if SK_ENABLE_INST_COUNT
-    // Make the instance count available publicly.
-    static int InstanceCount() { return GetInstanceCount(); }
-#endif
-
     int fID;
 
 private:
-    SK_DECLARE_INST_COUNT(ListElement);
+
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(ListElement);
 };
 
 static void check_list(const SkTInternalLList<ListElement>& list,
                        skiatest::Reporter* reporter,
                        bool empty,
                        int numElements,
                        bool in0, bool in1, bool in2, bool in3,
                        ListElement elements[4]) {
 
@@ skipping 88 matching lines @@
 
     for (int i = 1; i <= 16; i *= 2) {
 
         ElList list1(i);
         ElList list2(i);
         Iter iter1;
         Iter iter2;
         Iter iter3;
         Iter iter4;
 
-#if SK_ENABLE_INST_COUNT
-        SkASSERT(0 == ListElement::InstanceCount());
-#endif
-
         REPORTER_ASSERT(reporter, list1.isEmpty());
         REPORTER_ASSERT(reporter, NULL == iter1.init(list1, Iter::kHead_IterStart));
         REPORTER_ASSERT(reporter, NULL == iter1.init(list1, Iter::kTail_IterStart));
         // Try popping an empty list
         list1.popHead();
         list1.popTail();
         REPORTER_ASSERT(reporter, list1.isEmpty());
         REPORTER_ASSERT(reporter, list1 == list2);
 
         // Create two identical lists, one by appending to head and the other to the tail.
         list1.addToHead(ListElement(1));
         list2.addToTail(ListElement(1));
-#if SK_ENABLE_INST_COUNT
-        SkASSERT(2 == ListElement::InstanceCount());
-#endif
         iter1.init(list1, Iter::kHead_IterStart);
         iter2.init(list1, Iter::kTail_IterStart);
         REPORTER_ASSERT(reporter, iter1.get()->fID == iter2.get()->fID);
         iter3.init(list2, Iter::kHead_IterStart);
         iter4.init(list2, Iter::kTail_IterStart);
         REPORTER_ASSERT(reporter, iter3.get()->fID == iter1.get()->fID);
         REPORTER_ASSERT(reporter, iter4.get()->fID == iter1.get()->fID);
         REPORTER_ASSERT(reporter, list1 == list2);
 
         list2.reset();
 
         // use both before/after in-place construction on an empty list
         SkNEW_INSERT_IN_LLIST_BEFORE(&list2, list2.headIter(), ListElement, (1));
         REPORTER_ASSERT(reporter, list2 == list1);
         list2.reset();
 
         SkNEW_INSERT_IN_LLIST_AFTER(&list2, list2.tailIter(), ListElement, (1));
         REPORTER_ASSERT(reporter, list2 == list1);
 
         // add an element to the second list, check that iters are still valid
         iter3.init(list2, Iter::kHead_IterStart);
         iter4.init(list2, Iter::kTail_IterStart);
         list2.addToHead(ListElement(2));
 
-#if SK_ENABLE_INST_COUNT
-        SkASSERT(3 == ListElement::InstanceCount());
-#endif
-
         REPORTER_ASSERT(reporter, iter3.get()->fID == iter1.get()->fID);
         REPORTER_ASSERT(reporter, iter4.get()->fID == iter1.get()->fID);
         REPORTER_ASSERT(reporter, 1 == Iter(list2, Iter::kTail_IterStart).get()->fID);
         REPORTER_ASSERT(reporter, 2 == Iter(list2, Iter::kHead_IterStart).get()->fID);
         REPORTER_ASSERT(reporter, list1 != list2);
         list1.addToHead(ListElement(2));
         REPORTER_ASSERT(reporter, list1 == list2);
-#if SK_ENABLE_INST_COUNT
-        SkASSERT(4 == ListElement::InstanceCount());
-#endif
         REPORTER_ASSERT(reporter, !list1.isEmpty());
 
         list1.reset();
         list2.reset();
-#if SK_ENABLE_INST_COUNT
-        SkASSERT(0 == ListElement::InstanceCount());
-#endif
         REPORTER_ASSERT(reporter, list1.isEmpty() && list2.isEmpty());
 
         // randomly perform insertions and deletions on a list and perform tests
         int count = 0;
         for (int j = 0; j < 100; ++j) {
             if (list1.isEmpty() || random.nextBiasedBool(3  * SK_Scalar1 / 4)) {
                 int id = j;
                 // Choose one of three ways to insert a new element: at the head, at the tail,
                 // before a random element, after a random element
                 int numValidMethods = 0 == count ? 2 : 4;
@@ skipping 82 matching lines @@
                 Iter pn = prev; pn.next();
                 Iter np = next; np.prev();
                 // pn should match next unless the target node was the head, in which case prev
                 // walked off the list.
                 REPORTER_ASSERT(reporter, pn.get() == next.get() || NULL == prev.get());
                 // Similarly, np should match prev unless next originally walked off the tail.
                 REPORTER_ASSERT(reporter, np.get() == prev.get() || NULL == next.get());
                 --count;
             }
             REPORTER_ASSERT(reporter, count == list1.count());
-#if SK_ENABLE_INST_COUNT
-            SkASSERT(count == ListElement::InstanceCount());
-#endif
         }
         list1.reset();
-#if SK_ENABLE_INST_COUNT
-        SkASSERT(0 == ListElement::InstanceCount());
-#endif
     }
 }
 
 DEF_TEST(LList, reporter) {
     TestTInternalLList(reporter);
     TestTLList(reporter);
 }