ImageResource: Reset the encoded image size after receiving all data

third_party/WebKit/Source/core/fetch/Resource.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 151 matching lines @@
     PreloadReferencedWhileComplete
   };
   PreloadResult getPreloadResult() const {
     return static_cast<PreloadResult>(m_preloadResult);
   }
 
   Status getStatus() const { return static_cast<Status>(m_status); }
   void setStatus(Status status) { m_status = status; }
 
   size_t size() const { return encodedSize() + decodedSize() + overheadSize(); }
+
+  // Returns the size of content (response body) before decoding. Adding a new
+  // usage of this function is not recommended (See the TODO below).
+  //
+  // TODO(hiroshige): Now encodedSize/decodedSize states are inconsistent and
+  // need to be refactored (crbug/643135).
   size_t encodedSize() const { return m_encodedSize; }
+
+  // Returns the current memory usage for the encoded data. Adding a new usage
+  // of this function is not recommended as the same reason as |encodedSize()|.
+  //
+  // |encodedSize()| and |encodedSizeMemoryUsageForTesting()| can return
+  // different values, e.g., when ImageResource purges encoded image data after
+  // finishing loading.
+  size_t encodedSizeMemoryUsageForTesting() const {
+    return m_encodedSizeMemoryUsage;
+  }
+
   size_t decodedSize() const { return m_decodedSize; }
   size_t overheadSize() const { return m_overheadSize; }
 
   bool isLoaded() const { return m_status > Pending; }
 
   bool isLoading() const { return m_status == Pending; }
   bool stillNeedsLoad() const { return m_status < Pending; }
 
   void setLoader(ResourceLoader*);
   ResourceLoader* loader() const { return m_loader.get(); }
@@ skipping 129 matching lines @@
   void notifyClientsInternal(MarkFinishedOption);
   void markClientFinished(ResourceClient*);
 
   virtual bool hasClientsOrObservers() const {
     return !m_clients.isEmpty() || !m_clientsAwaitingCallback.isEmpty() ||
            !m_finishedClients.isEmpty();
   }
   virtual void destroyDecodedDataForFailedRevalidation() {}
 
   void setEncodedSize(size_t);
+  void setEncodedSizeMemoryUsage(size_t);
   void setDecodedSize(size_t);
   void didAccessDecodedData();
 
   void finishPendingClients();
 
   virtual void didAddClient(ResourceClient*);
   void willAddClientOrObserver(PreloadReferencePolicy);
 
   // |this| object may be dead after didRemoveClientOrObserver().
   void didRemoveClientOrObserver();
@@ skipping 62 matching lines @@
   Member<CachedMetadataHandlerImpl> m_cacheHandler;
   RefPtr<SecurityOrigin> m_fetcherSecurityOrigin;
 
   ResourceError m_error;
 
   double m_loadFinishTime;
 
   unsigned long m_identifier;
 
   size_t m_encodedSize;
+  size_t m_encodedSizeMemoryUsage;
   size_t m_decodedSize;
 
   // Resource::calculateOverheadSize() is affected by changes in
   // |m_resourceRequest.url()|, but |m_overheadSize| is not updated after
   // initial |m_resourceRequest| is given, to reduce MemoryCache manipulation
   // and thus potential bugs. crbug.com/594644
   const size_t m_overheadSize;
 
   unsigned m_preloadCount;
 
@@ skipping 50 matching lines @@
 };
 
 #define DEFINE_RESOURCE_TYPE_CASTS(typeName)                   \
   DEFINE_TYPE_CASTS(typeName##Resource, Resource, resource,    \
                     resource->getType() == Resource::typeName, \
                     resource.getType() == Resource::typeName);
 
 }  // namespace blink
 
 #endif