Style Change: SkNEW->new; SkDELETE->delete

src/core/SkStream.cpp

 
 /*
  * 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.
  */
 
 
 #include "SkStream.h"
@@ skipping 372 matching lines @@
 
 bool SkMemoryStream::isAtEnd() const {
     return fOffset == fData->size();
 }
 
 bool SkMemoryStream::rewind() {
     fOffset = 0;
     return true;
 }
 
-SkMemoryStream* SkMemoryStream::duplicate() const {
-    return SkNEW_ARGS(SkMemoryStream, (fData));
-}
+SkMemoryStream* SkMemoryStream::duplicate() const { return new SkMemoryStream(fData); }
 
 size_t SkMemoryStream::getPosition() const {
     return fOffset;
 }
 
 bool SkMemoryStream::seek(size_t position) {
     fOffset = position > fData->size()
             ? fData->size()
             : position;
     return true;
@@ skipping 274 matching lines @@
             block = next;
         }
     }
 
     SkDynamicMemoryWStream::Block* const fHead;
 };
 
 class SkBlockMemoryStream : public SkStreamAsset {
 public:
     SkBlockMemoryStream(SkDynamicMemoryWStream::Block* head, size_t size)
-        : fBlockMemory(SkNEW_ARGS(SkBlockMemoryRefCnt, (head))), fCurrent(head)
-        , fSize(size) , fOffset(0), fCurrentOffset(0) { }
+        : fBlockMemory(new SkBlockMemoryRefCnt(head))
+        , fCurrent(head)
+        , fSize(size)
+        , fOffset(0)
+        , fCurrentOffset(0) {}
 
     SkBlockMemoryStream(SkBlockMemoryRefCnt* headRef, size_t size)
         : fBlockMemory(SkRef(headRef)), fCurrent(fBlockMemory->fHead)
         , fSize(size) , fOffset(0), fCurrentOffset(0) { }
 
     size_t read(void* buffer, size_t rawCount) override {
         size_t count = rawCount;
         if (fOffset + count > fSize) {
             count = fSize - fOffset;
         }
@@ skipping 44 matching lines @@
     }
 
     bool rewind() override {
         fCurrent = fBlockMemory->fHead;
         fOffset = 0;
         fCurrentOffset = 0;
         return true;
     }
 
     SkBlockMemoryStream* duplicate() const override {
-        return SkNEW_ARGS(SkBlockMemoryStream, (fBlockMemory.get(), fSize));
+        return new SkBlockMemoryStream(fBlockMemory.get(), fSize);
     }
 
     size_t getPosition() const override {
         return fOffset;
     }
 
     bool seek(size_t position) override {
         // If possible, skip forward.
         if (position >= fOffset) {
             size_t skipAmount = position - fOffset;
@@ skipping 36 matching lines @@
 private:
     SkAutoTUnref<SkBlockMemoryRefCnt> const fBlockMemory;
     SkDynamicMemoryWStream::Block const * fCurrent;
     size_t const fSize;
     size_t fOffset;
     size_t fCurrentOffset;
 };
 
 SkStreamAsset* SkDynamicMemoryWStream::detachAsStream() {
     if (fCopy) {
-        SkMemoryStream* stream = SkNEW_ARGS(SkMemoryStream, (fCopy));
+        SkMemoryStream* stream = new SkMemoryStream(fCopy);
         this->reset();
         return stream;
     }
-    SkBlockMemoryStream* stream = SkNEW_ARGS(SkBlockMemoryStream, (fHead, fBytesWritten));
+    SkBlockMemoryStream* stream = new SkBlockMemoryStream(fHead, fBytesWritten);
     fHead = 0;
     this->reset();
     return stream;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkDebugWStream::newline()
 {
 #if defined(SK_DEBUG) || defined(SK_DEVELOPER)
@@ skipping 26 matching lines @@
     }
 
     SkData* data = SkData::NewFromFILE(file);
     sk_fclose(file);
     return data;
 }
 
 SkStreamAsset* SkStream::NewFromFile(const char path[]) {
     SkAutoTUnref<SkData> data(mmap_filename(path));
     if (data.get()) {
-        return SkNEW_ARGS(SkMemoryStream, (data.get()));
+        return new SkMemoryStream(data.get());
     }
 
     // If we get here, then our attempt at using mmap failed, so try normal
     // file access.
-    SkFILEStream* stream = SkNEW_ARGS(SkFILEStream, (path));
+    SkFILEStream* stream = new SkFILEStream(path);
     if (!stream->isValid()) {
-        SkDELETE(stream);
+        delete stream;
         stream = NULL;
     }
     return stream;
 }
 
 // Declared in SkStreamPriv.h:
 size_t SkCopyStreamToStorage(SkAutoMalloc* storage, SkStream* stream) {
     SkASSERT(storage != NULL);
     SkASSERT(stream != NULL);
 
@@ skipping 49 matching lines @@
     if (dupStream) {
         return dupStream.detach();
     }
     stream->rewind();
     if (stream->hasLength()) {
         size_t length = stream->getLength();
         if (stream->hasPosition()) {  // If stream has length, but can't rewind.
             length -= stream->getPosition();
         }
         SkAutoTUnref<SkData> data(SkData::NewFromStream(stream, length));
-        return SkNEW_ARGS(SkMemoryStream, (data.get()));
+        return new SkMemoryStream(data.get());
     }
     SkDynamicMemoryWStream tempStream;
     const size_t bufferSize = 4096;
     char buffer[bufferSize];
     do {
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
     } while (!stream->isAtEnd());
     return tempStream.detachAsStream();  // returns a SkBlockMemoryStream,
                                          // cheaper than copying to SkData
@@ skipping 13 matching lines @@
     while (true) {
         count = input->read(scratch, sizeof(scratch));
         if (0 == count) {
             return true;
         }
         if (!out->write(scratch, count)) {
             return false;
         }
     }
 }