staticMethod -> StaticMethod

src/core/SkPictureFlat.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPictureFlat_DEFINED
 #define SkPictureFlat_DEFINED
 
@@ skipping 247 matching lines @@
     template <typename Traits, typename T>
     static SkFlatData* Create(SkFlatController* controller, const T& obj, int index) {
         // A buffer of 256 bytes should fit most paints, regions, and matrices.
         uint32_t storage[64];
         SkWriteBuffer buffer(storage, sizeof(storage), controller->getWriteBufferFlags());
 
         buffer.setBitmapHeap(controller->getBitmapHeap());
         buffer.setTypefaceRecorder(controller->getTypefaceSet());
         buffer.setNamedFactoryRecorder(controller->getNamedFactorySet());
 
-        Traits::flatten(buffer, obj);
+        Traits::Flatten(buffer, obj);
         size_t size = buffer.bytesWritten();
         SkASSERT(SkIsAlign4(size));
 
         // Allocate enough memory to hold SkFlatData struct and the flat data itself.
         size_t allocSize = sizeof(SkFlatData) + size;
         SkFlatData* result = (SkFlatData*) controller->allocThrow(allocSize);
 
         // Put the serialized contents into the data section of the new allocation.
         buffer.writeToMemory(result->data());
         // Stamp the index, size and checksum in the header.
         result->stampHeader(index, SkToS32(size));
         return result;
     }
 
     // Unflatten this into result, using bitmapHeap and facePlayback for bitmaps and fonts if given
     template <typename Traits, typename T>
     void unflatten(T* result,
                    SkBitmapHeap* bitmapHeap = NULL,
                    SkTypefacePlayback* facePlayback = NULL) const {
         SkReadBuffer buffer(this->data(), fFlatSize);
 
         if (bitmapHeap) {
             buffer.setBitmapStorage(bitmapHeap);
         }
         if (facePlayback) {
             facePlayback->setupBuffer(buffer);
         }
 
-        Traits::unflatten(buffer, result);
+        Traits::Unflatten(buffer, result);
         SkASSERT(fFlatSize == (int32_t)buffer.offset());
     }
 
     // Do these contain the same data?  Ignores index() and topBot().
     bool operator==(const SkFlatData& that) const {
         if (this->checksum() != that.checksum() || this->flatSize() != that.flatSize()) {
             return false;
         }
         return memcmp(this->data(), that.data(), this->flatSize()) == 0;
     }
@@ skipping 201 matching lines @@
         return detached;
     }
 
     // This reference is valid only until the next call to resetScratch() or detachScratch().
     const SkFlatData& resetScratch(const T& element, int index) {
         this->lazyInit();
 
         // Layout of fScratch: [ SkFlatData header, 20 bytes ] [ data ..., 4-byte aligned ]
         fScratch.reset();
         fScratch.reserve(sizeof(SkFlatData));
-        Traits::flatten(fScratch, element);
+        Traits::Flatten(fScratch, element);
         const size_t dataSize = fScratch.bytesWritten() - sizeof(SkFlatData);
 
         // Reinterpret data in fScratch as an SkFlatData.
         SkFlatData* scratch = (SkFlatData*)fScratch.getWriter32()->contiguousArray();
         SkASSERT(scratch != NULL);
         scratch->stampHeader(index, dataSize);
         return *scratch;
     }
 
     // This result is owned by fController and lives as long as it does (unless unalloc'd).
@@ skipping 25 matching lines @@
 
     // For index -> SkFlatData.  0-based, while all indices in the API are 1-based.  Careful!
     SkTDArray<const SkFlatData*> fIndexedData;
 
     // For SkFlatData -> cached SkFlatData, which has index().
     SkTDynamicHash<SkFlatData, SkFlatData,
                    SkFlatData::Identity, SkFlatData::Hash, SkFlatData::Equal> fHash;
 };
 
 struct SkPaintTraits {
-    static void flatten(SkWriteBuffer& buffer, const SkPaint& paint) {
+    static void Flatten(SkWriteBuffer& buffer, const SkPaint& paint) {
         paint.flatten(buffer);
     }
-    static void unflatten(SkReadBuffer& buffer, SkPaint* paint) {
+    static void Unflatten(SkReadBuffer& buffer, SkPaint* paint) {
         paint->unflatten(buffer);
     }
 };
 typedef SkFlatDictionary<SkPaint, SkPaintTraits> SkPaintDictionary;
 
 class SkChunkFlatController : public SkFlatController {
 public:
     SkChunkFlatController(size_t minSize)
     : fHeap(minSize)
     , fTypefaceSet(SkNEW(SkRefCntSet))
@@ skipping 22 matching lines @@
     }
 
 private:
     SkChunkAlloc               fHeap;
     SkAutoTUnref<SkRefCntSet>  fTypefaceSet;
     void*                      fLastAllocated;
     mutable SkTypefacePlayback fTypefacePlayback;
 };
 
 #endif