Delete unused fNamedFactorySet from SkWriteBuffer

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 212 matching lines @@
     SkRefCntSet* getTypefaceSet() { return fTypefaceSet; }
 
     /**
      * Used during unflattening of the SkFlatData objects in the
      * SkFlatDictionary. Needs to be set by the protected setTypefacePlayback
      * and needs to be reset to the SkRefCntSet passed to setTypefaceSet.
      */
     SkTypefacePlayback* getTypefacePlayback() { return fTypefacePlayback; }
 
     /**
-     * Optional factory recorder used during creation of SkFlatData objects. Set
-     * using the protected method setNamedFactorySet.
-     */
-    SkNamedFactorySet* getNamedFactorySet() { return fFactorySet; }
-
-    /**
      * Flags to use during creation of SkFlatData objects. Defaults to zero.
      */
     uint32_t getWriteBufferFlags() { return fWriteBufferFlags; }
 
 protected:
     /**
      * Set an SkBitmapHeap to be used to store/read SkBitmaps. Ref counted.
      */
     void setBitmapHeap(SkBitmapHeap*);
 
     /**
      * Set an SkRefCntSet to be used to store SkTypefaces during flattening. Ref
      * counted.
      */
     void setTypefaceSet(SkRefCntSet*);
 
     /**
      * Set an SkTypefacePlayback to be used to find references to SkTypefaces
      * during unflattening. Should be reset to the set provided to
      * setTypefaceSet.
      */
     void setTypefacePlayback(SkTypefacePlayback*);
 
-    /**
-     * Set an SkNamedFactorySet to be used to store Factorys and their
-     * corresponding names during flattening. Ref counted. Returns the same
-     * set as a convenience.
-     */
-    SkNamedFactorySet* setNamedFactorySet(SkNamedFactorySet*);
-
 private:
     SkBitmapHeap*       fBitmapHeap;
     SkRefCntSet*        fTypefaceSet;
     SkTypefacePlayback* fTypefacePlayback;
-    SkNamedFactorySet*  fFactorySet;
     const uint32_t      fWriteBufferFlags;
 
     typedef SkRefCnt INHERITED;
 };
 
 class SkFlatData {
 public:
     // Flatten obj into an SkFlatData with this index.  controller owns the SkFlatData*.
     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());

[mtklein, 2016/04/19 14:06:39]

Walk me through how it's unused again?  It looks like we do set it.

[msarett, 2016/04/19 14:13:29]

It's never set on the SkFlatController - so this call to set() always passes in
nullptr.

[mtklein, 2016/04/19 14:18:36]

Ah, brilliant!

 
         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.
@@ skipping 190 matching lines @@
     // be fully set up by the time we get it in the constructor.
     void lazyInit() {
         if (fReady) {
             return;
         }
 
         // Without a bitmap heap, we'll flatten bitmaps into paints.  That's never what you want.
         SkASSERT(fController->getBitmapHeap() != nullptr);
         fScratch.setBitmapHeap(fController->getBitmapHeap());
         fScratch.setTypefaceRecorder(fController->getTypefaceSet());
-        fScratch.setNamedFactoryRecorder(fController->getNamedFactorySet());
         fReady = true;
     }
 
     // As findAndReturnFlat, but returns a mutable pointer for internal use.
     SkFlatData* findAndReturnMutableFlat(const T& element) {
         // Only valid until the next call to resetScratch().
         const SkFlatData& scratch = this->resetScratch(element, this->count()+1);
 
         SkFlatData* candidate = fHash.find(scratch);
         if (candidate != nullptr) {
@@ skipping 52 matching lines @@
     bool fReady;
 
     // 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::HashTraits> fHash;
 };
 
 #endif