Use an array of nonpurgeable resources in GrResourceCache

include/gpu/GrGpuResource.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpuResource_DEFINED
 #define GrGpuResource_DEFINED
 
 #include "GrResourceKey.h"
 #include "GrTypesPriv.h"
 #include "SkData.h"
 #include "SkInstCnt.h"
-#include "SkTInternalLList.h"
 
 class GrContext;
 class GrGpu;
 class GrResourceCache;
 
 /**
  * Base class for GrGpuResource. Handles the various types of refs we need. Separated out as a base
  * class to isolate the ref-cnting behavior and provide friendship without exposing all of
  * GrGpuResource.
  *
@@ skipping 250 matching lines @@
     void removeScratchKey();
     void makeBudgeted();
     void makeUnbudgeted();
 
 #ifdef SK_DEBUG
     friend class GrGpu; // for assert in GrGpu to access getGpu
 #endif
 
     static uint32_t CreateUniqueID();
 
-    // We're in an internal doubly linked list owned by GrResourceCache. TODO: Replace this with an
-    // array of unpurgeable resources in the cache.
-    SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuResource);
-
     // These are used for cache bookkeeping
     int                         fCacheArrayIndex;
     uint32_t                    fTimestamp;
 
     static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
     GrScratchKey                fScratchKey;
     GrContentKey                fContentKey;
 
     // This is not ref'ed but abandon() or release() will be called before the GrGpu object
     // is destroyed. Those calls set will this to NULL.
     GrGpu*                      fGpu;
     mutable size_t              fGpuMemorySize;
 
     LifeCycle                   fLifeCycle;
     const uint32_t              fUniqueID;
 
     SkAutoTUnref<const SkData>  fData;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyIsPurgeable.
 };
 
 #endif