Reserve Vector's capacity manually in CachedMetadata

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 31 matching lines @@
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include <algorithm>
 #include <memory>
+#include <stdint.h>
 
 namespace blink {
 
 // These response headers are not copied from a revalidated response to the
 // cached response headers. For compatibility, this list is based on Chromium's
 // net/http/http_response_headers.cc.
 const char* const headersToIgnoreAfterRevalidation[] = {
     "allow",
     "connection",
     "etag",
@@ skipping 33 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 setCachedMetadata(uint32_t, const char*, size_t, CacheType) override;
     void clearCachedMetadata(CacheType) override;
-    PassRefPtr<CachedMetadata> cachedMetadata(unsigned) const override;
+    PassRefPtr<CachedMetadata> cachedMetadata(uint32_t) 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;
 
 private:
     Member<Resource> m_resource;
 };
 
 Resource::CachedMetadataHandlerImpl::CachedMetadataHandlerImpl(Resource* resource)
     : m_resource(resource)
 {
 }
 
 DEFINE_TRACE(Resource::CachedMetadataHandlerImpl)
 {
     visitor->trace(m_resource);
     CachedMetadataHandler::trace(visitor);
 }
 
-void Resource::CachedMetadataHandlerImpl::setCachedMetadata(unsigned dataTypeID, const char* data, size_t size, CachedMetadataHandler::CacheType cacheType)
+void Resource::CachedMetadataHandlerImpl::setCachedMetadata(uint32_t dataTypeID, const char* data, size_t size, CachedMetadataHandler::CacheType cacheType)
 {
     // Currently, only one type of cached metadata per resource is supported.
     // If the need arises for multiple types of metadata per resource this could
     // be enhanced to store types of metadata in a map.
     ASSERT(!m_cachedMetadata);
     m_cachedMetadata = CachedMetadata::create(dataTypeID, data, size);
     if (cacheType == CachedMetadataHandler::SendToPlatform)
         sendToPlatform();
 }
 
 void Resource::CachedMetadataHandlerImpl::clearCachedMetadata(CachedMetadataHandler::CacheType cacheType)
 {
     m_cachedMetadata.clear();
     if (cacheType == CachedMetadataHandler::SendToPlatform)
         sendToPlatform();
 }
 
-PassRefPtr<CachedMetadata> Resource::CachedMetadataHandlerImpl::cachedMetadata(unsigned dataTypeID) const
+PassRefPtr<CachedMetadata> Resource::CachedMetadataHandlerImpl::cachedMetadata(uint32_t dataTypeID) const
 {
     if (!m_cachedMetadata || m_cachedMetadata->dataTypeID() != dataTypeID)
         return nullptr;
     return m_cachedMetadata.get();
 }
 
 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.
     // If this triggers, it indicates an efficiency problem which is most
     // likely unexpected in code designed to improve performance.
     ASSERT(!m_cachedMetadata);
-    m_cachedMetadata = CachedMetadata::deserialize(data, size);
+    m_cachedMetadata = CachedMetadata::createFromSerializedData(data, size);
 }
 
 void Resource::CachedMetadataHandlerImpl::sendToPlatform()
 {
     if (m_cachedMetadata) {
-        const Vector<char>& serializedData = m_cachedMetadata->serialize();
+        const Vector<char>& serializedData = m_cachedMetadata->serializedData();
         Platform::current()->cacheMetadata(response().url(), response().responseTime(), serializedData.data(), serializedData.size());
     } else {
         Platform::current()->cacheMetadata(response().url(), response().responseTime(), nullptr, 0);
     }
 }
 
 class Resource::ServiceWorkerResponseCachedMetadataHandler : public Resource::CachedMetadataHandlerImpl {
 public:
     static Resource::CachedMetadataHandlerImpl* create(Resource* resource, SecurityOrigin* securityOrigin)
     {
@@ skipping 25 matching lines @@
 void Resource::ServiceWorkerResponseCachedMetadataHandler::sendToPlatform()
 {
     // We don't support sending the metadata to the platform when the response
     // was directly fetched via a ServiceWorker
     // (eg: FetchEvent.respondWith(fetch(FetchEvent.request))) to prevent an
     // attacker's Service Worker from poisoning the metadata cache of HTTPCache.
     if (response().cacheStorageCacheName().isNull())
         return;
 
     if (m_cachedMetadata) {
-        const Vector<char>& serializedData = m_cachedMetadata->serialize();
+        const Vector<char>& serializedData = m_cachedMetadata->serializedData();
         Platform::current()->cacheMetadataInCacheStorage(response().url(), response().responseTime(), serializedData.data(), serializedData.size(), WebSecurityOrigin(m_securityOrigin), response().cacheStorageCacheName());
     } else {
         Platform::current()->cacheMetadataInCacheStorage(response().url(), response().responseTime(), nullptr, 0, WebSecurityOrigin(m_securityOrigin), response().cacheStorageCacheName());
     }
 }
 
 class Resource::ResourceCallback final : public GarbageCollectedFinalized<ResourceCallback> {
 public:
     static ResourceCallback& callbackHandler();
     DECLARE_TRACE();
@@ skipping 832 matching lines @@
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::Manifest:
         return false;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 } // namespace blink