add SK_ATTR_DEPRECATED -- will need to disable for chrome, since it triggers a warning

tests/Writer32Test.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
@@ skipping 68 matching lines @@
     void* p1 = &writer;
 
     // try writing ptrs where at least one of them may be at a non-multiple of
     // 8 boundary, to confirm this works on 64bit machines.
 
     writer.writePtr(p0);
     writer.write8(0x33);
     writer.writePtr(p1);
     writer.write8(0x66);
 
-    size_t size = writer.size();
+    size_t size = writer.bytesWritten();
     REPORTER_ASSERT(reporter, 2 * sizeof(void*) + 2 * sizeof(int32_t));
 
     char buffer[32];
     SkASSERT(sizeof(buffer) >= size);
     writer.flatten(buffer);
 
     SkReader32 reader(buffer, size);
     REPORTER_ASSERT(reporter, reader.readPtr() == p0);
     REPORTER_ASSERT(reporter, reader.readInt() == 0x33);
     REPORTER_ASSERT(reporter, reader.readPtr() == p1);
     REPORTER_ASSERT(reporter, reader.readInt() == 0x66);
 }
 
 static void test1(skiatest::Reporter* reporter, SkWriter32* writer) {
     const uint32_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     for (size_t i = 0; i < SK_ARRAY_COUNT(data); ++i) {
-        REPORTER_ASSERT(reporter, i*4 == writer->size());
+        REPORTER_ASSERT(reporter, i*4 == writer->bytesWritten());
         writer->write32(data[i]);
         uint32_t* addr = writer->peek32(i * 4);
         REPORTER_ASSERT(reporter, data[i] == *addr);
     }
 
     char buffer[sizeof(data)];
-    REPORTER_ASSERT(reporter, sizeof(buffer) == writer->size());
+    REPORTER_ASSERT(reporter, sizeof(buffer) == writer->bytesWritten());
     writer->flatten(buffer);
     REPORTER_ASSERT(reporter, !memcmp(data, buffer, sizeof(buffer)));
 }
 
 static void test2(skiatest::Reporter* reporter, SkWriter32* writer) {
     static const char gStr[] = "abcdefghimjklmnopqrstuvwxyz";
     size_t i;
 
     size_t len = 0;
     for (i = 0; i <= 26; ++i) {
         len += SkWriter32::WriteStringSize(gStr, i);
         writer->writeString(gStr, i);
     }
-    REPORTER_ASSERT(reporter, writer->size() == len);
+    REPORTER_ASSERT(reporter, writer->bytesWritten() == len);
 
     SkAutoMalloc storage(len);
     writer->flatten(storage.get());
 
     SkReader32 reader;
     reader.setMemory(storage.get(), len);
     for (i = 0; i <= 26; ++i) {
         REPORTER_ASSERT(reporter, !reader.eof());
         const char* str = reader.readString(&len);
         REPORTER_ASSERT(reporter, i == len);
@@ skipping 22 matching lines @@
             *ptr++ = rand.nextU();
         }
 
         // Write  the random data to the writer at different lengths for
         // different alignments.
         for (size_t len = 0; len < dataSize; len++) {
             writer->writePad(originalData.get(), len);
         }
     }
 
-    uint32_t totalBytes = writer->size();
+    uint32_t totalBytes = writer->bytesWritten();
 
     SkAutoMalloc readStorage(totalBytes);
     writer->flatten(readStorage.get());
 
     SkReader32 reader;
     reader.setMemory(readStorage.get(), totalBytes);
 
     for (size_t len = 0; len < dataSize; len++) {
         const char* readPtr = static_cast<const char*>(reader.skip(len));
         // Ensure that the data read is the same as what was written.
@@ skipping 67 matching lines @@
     }
 
     test_reserve(reporter);
     test_string_null(reporter);
     test_ptr(reporter);
     test_rewind(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Writer32", Writer32Class, Tests)