Make Resource MemoryCoordinatorClient.

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

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@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 86 matching lines @@
 class Resource::CachedMetadataHandlerImpl : public CachedMetadataHandler {
 public:
     static Resource::CachedMetadataHandlerImpl* create(Resource* resource)
     {
         return new CachedMetadataHandlerImpl(resource);
     }
     ~CachedMetadataHandlerImpl() override {}
     DECLARE_VIRTUAL_TRACE();
     void setCachedMetadata(unsigned, const char*, size_t, CacheType) override;
     void clearCachedMetadata(CacheType) override;
-    CachedMetadata* cachedMetadata(unsigned) const override;
+    PassRefPtr<CachedMetadata> cachedMetadata(unsigned) const override;
     String encoding() const override;
     // Sets the serialized metadata retrieved from the platform's cache.
     void setSerializedCachedMetadata(const char*, size_t);
 
 protected:
     explicit CachedMetadataHandlerImpl(Resource*);
     virtual void sendToPlatform();
     const ResourceResponse& response() const { return m_resource->response(); }
 
     RefPtr<CachedMetadata> m_cachedMetadata;
@@ skipping 24 matching lines @@
         sendToPlatform();
 }
 
 void Resource::CachedMetadataHandlerImpl::clearCachedMetadata(CachedMetadataHandler::CacheType cacheType)
 {
     m_cachedMetadata.clear();
     if (cacheType == CachedMetadataHandler::SendToPlatform)
         sendToPlatform();
 }
 
-CachedMetadata* Resource::CachedMetadataHandlerImpl::cachedMetadata(unsigned dataTypeID) const
+PassRefPtr<CachedMetadata> Resource::CachedMetadataHandlerImpl::cachedMetadata(unsigned dataTypeID) const
 {
     if (!m_cachedMetadata || m_cachedMetadata->dataTypeID() != dataTypeID)
         return nullptr;
     return m_cachedMetadata.get();

[hiroshige, 2016/08/25 12:48:11]

We can remove .get() here.

 }
 
 String Resource::CachedMetadataHandlerImpl::encoding() const
 {
     return m_resource->encoding();
 }
 
 void Resource::CachedMetadataHandlerImpl::setSerializedCachedMetadata(const char* data, size_t size)
 {
     // We only expect to receive cached metadata from the platform once.
@@ skipping 145 matching lines @@
     , m_responseTimestamp(currentTime())
     , m_cancelTimer(this, &Resource::cancelTimerFired)
     , m_resourceRequest(request)
 {
     ASSERT(m_type == unsigned(type)); // m_type is a bitfield, so this tests careless updates of the enum.
     InstanceCounters::incrementCounter(InstanceCounters::ResourceCounter);
 
     // Currently we support the metadata caching only for HTTP family.
     if (m_resourceRequest.url().protocolIsInHTTPFamily())
         m_cacheHandler = CachedMetadataHandlerImpl::create(this);
+    MemoryCoordinator::instance().registerClient(this);
 }
 
 Resource::~Resource()
 {
     InstanceCounters::decrementCounter(InstanceCounters::ResourceCounter);
 }
 
 DEFINE_TRACE(Resource)
 {
     visitor->trace(m_loader);
     visitor->trace(m_cacheHandler);
+    MemoryCoordinatorClient::trace(visitor);
 }
 
 void Resource::setLoader(ResourceLoader* loader)
 {
     RELEASE_ASSERT(!m_loader);
     ASSERT(stillNeedsLoad());
     m_loader = loader;
     m_status = Pending;
 }
 
@@ skipping 460 matching lines @@
 
     // Prevent the case when there are clients waiting but no callback scheduled.
     ASSERT(m_clientsAwaitingCallback.isEmpty() || scheduled);
 }
 
 void Resource::prune()
 {
     destroyDecodedDataIfPossible();
 }
 
+void Resource::prepareToSuspend()
+{
+    prune();
+    if (!m_cacheHandler)
+        return;
+    m_cacheHandler->clearCachedMetadata(CachedMetadataHandler::CacheLocally);
+}
+
 void Resource::onMemoryDump(WebMemoryDumpLevelOfDetail levelOfDetail, WebProcessMemoryDump* memoryDump) const
 {
     static const size_t kMaxURLReportLength = 128;
     static const int kMaxResourceClientToShowInMemoryInfra = 10;
 
     const String dumpName = getMemoryDumpName();
     WebMemoryAllocatorDump* dump = memoryDump->createMemoryAllocatorDump(dumpName);
     dump->addScalar("encoded_size", "bytes", m_encodedSize);
     if (hasClientsOrObservers())
         dump->addScalar("live_size", "bytes", m_encodedSize);
@@ skipping 226 matching lines @@
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::Manifest:
         return false;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 } // namespace blink