remove SkInstCnt

include/core/SkStream.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkStream_DEFINED
 #define SkStream_DEFINED
 
@@ skipping 163 matching lines @@
 class SK_API SkStreamMemory : public SkStreamAsset {
 public:
     SkStreamMemory* duplicate() const override = 0;
     SkStreamMemory* fork() const override = 0;
 
     const void* getMemoryBase() override = 0;
 };
 
 class SK_API SkWStream : SkNoncopyable {
 public:
-    SK_DECLARE_INST_COUNT(SkWStream)
-
     virtual ~SkWStream();
 
     /** Called to write bytes to a SkWStream. Returns true on success
         @param buffer the address of at least size bytes to be written to the stream
         @param size The number of bytes in buffer to write to the stream
         @return true on success
     */
     virtual bool write(const void* buffer, size_t size) = 0;
     virtual void newline();
     virtual void flush();
@@ skipping 28 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkString.h"
 #include <stdio.h>
 
 struct SkFILE;
 
 /** A stream that wraps a C FILE* file stream. */
 class SK_API SkFILEStream : public SkStreamAsset {
 public:
-    SK_DECLARE_INST_COUNT(SkFILEStream)
-
     /** Initialize the stream by calling sk_fopen on the specified path.
      *  This internal stream will be closed in the destructor.
      */
     explicit SkFILEStream(const char path[] = NULL);
 
     enum Ownership {
         kCallerPasses_Ownership,
         kCallerRetains_Ownership
     };
     /** Initialize the stream with an existing C file stream.
@@ skipping 33 matching lines @@
     SkString    fName;
     Ownership   fOwnership;
     // fData is lazilly initialized when needed.
     mutable SkAutoTUnref<SkData> fData;
 
     typedef SkStreamAsset INHERITED;
 };
 
 class SK_API SkMemoryStream : public SkStreamMemory {
 public:
-    SK_DECLARE_INST_COUNT(SkMemoryStream)
-
     SkMemoryStream();
 
     /** We allocate (and free) the memory. Write to it via getMemoryBase() */
     SkMemoryStream(size_t length);
 
     /** If copyData is true, the stream makes a private copy of the data. */
     SkMemoryStream(const void* data, size_t length, bool copyData = false);
 
     /** Use the specified data as the memory for this stream.
      *  The stream will call ref() on the data (assuming it is not NULL).
@@ skipping 50 matching lines @@
     SkData* fData;
     size_t  fOffset;
 
     typedef SkStreamMemory INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 class SK_API SkFILEWStream : public SkWStream {
 public:
-    SK_DECLARE_INST_COUNT(SkFILEWStream)
-
     SkFILEWStream(const char path[]);
     virtual ~SkFILEWStream();
 
     /** Returns true if the current path could be opened.
     */
     bool isValid() const { return fFILE != NULL; }
 
     bool write(const void* buffer, size_t size) override;
     void flush() override;
     size_t bytesWritten() const override;
 
 private:
     SkFILE* fFILE;
 
     typedef SkWStream INHERITED;
 };
 
 class SkMemoryWStream : public SkWStream {
 public:
-    SK_DECLARE_INST_COUNT(SkMemoryWStream)
-
     SkMemoryWStream(void* buffer, size_t size);
     bool write(const void* buffer, size_t size) override;
     size_t bytesWritten() const override { return fBytesWritten; }
 
 private:
     char*   fBuffer;
     size_t  fMaxLength;
     size_t  fBytesWritten;
 
     typedef SkWStream INHERITED;
 };
 
 class SK_API SkDynamicMemoryWStream : public SkWStream {
 public:
-    SK_DECLARE_INST_COUNT(SkDynamicMemoryWStream)
-
     SkDynamicMemoryWStream();
     virtual ~SkDynamicMemoryWStream();
 
     bool write(const void* buffer, size_t size) override;
     size_t bytesWritten() const override { return fBytesWritten; }
     // random access write
     // modifies stream and returns true if offset + size is less than or equal to getOffset()
     bool write(const void* buffer, size_t offset, size_t size);
     bool read(void* buffer, size_t offset, size_t size);
     size_t getOffset() const { return fBytesWritten; }
@@ skipping 27 matching lines @@
     friend class SkBlockMemoryStream;
     friend class SkBlockMemoryRefCnt;
 
     typedef SkWStream INHERITED;
 };
 
 
 class SK_API SkDebugWStream : public SkWStream {
 public:
     SkDebugWStream() : fBytesWritten(0) {}
-    SK_DECLARE_INST_COUNT(SkDebugWStream)
 
     // overrides
     bool write(const void* buffer, size_t size) override;
     void newline() override;
     size_t bytesWritten() const override { return fBytesWritten; }
 
 private:
     size_t fBytesWritten;
     typedef SkWStream INHERITED;
 };
 
 // for now
 typedef SkFILEStream SkURLStream;
 
 #endif