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

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef CachedMetadata_h
  32 #define CachedMetadata_h
  33
  34 #include "wtf/Forward.h"
  35 #include "wtf/RefCounted.h"
  36 #include "wtf/Vector.h"
  37
  38 namespace blink {
  39
  40 // Metadata retrieved from the embedding application's cache.
  41 //
  42 // Serialized data is NOT portable across architectures. However, reading the
  43 // data type ID will reject data generated with a different byte-order.
  44 class CachedMetadata : public RefCounted<CachedMetadata> {
  45 public:
  46     static PassRefPtr<CachedMetadata> create(unsigned dataTypeID, const char* data, size_t size)
  47     {
  48         return adoptRef(new CachedMetadata(dataTypeID, data, size));
  49     }
  50
  51     static PassRefPtr<CachedMetadata> deserialize(const char* data, size_t size)
  52     {
  53         return adoptRef(new CachedMetadata(data, size));
  54     }
  55
  56     const Vector<char>& serialize() const
  57     {
  58         return m_serializedData;
  59     }
  60
  61     ~CachedMetadata() { }
  62
  63     unsigned dataTypeID() const
  64     {
  65         return readUnsigned(dataTypeIDStart);
  66     }
  67
  68     const char* data() const
  69     {
  70         if (m_serializedData.size() < dataStart)
  71             return 0;
  72         return m_serializedData.data() + dataStart;
  73     }
  74
  75     size_t size() const
  76     {
  77         if (m_serializedData.size() < dataStart)
  78             return 0;
  79         return m_serializedData.size() - dataStart;
  80     }
  81
  82 private:
  83     // Reads an unsigned value at position. Returns 0 on error.
  84     unsigned readUnsigned(size_t position) const
  85     {
  86         if (m_serializedData.size() < position + sizeof(unsigned))
  87             return 0;
  88         return *reinterpret_cast_ptr<unsigned*>(const_cast<char*>(m_serializedData.data() + position));
  89     }
  90
  91     // Appends an unsigned value to the end of the serialized data.
  92     void appendUnsigned(unsigned value)
  93     {
  94         m_serializedData.append(reinterpret_cast<const char*>(&value), sizeof(unsigned));
  95     }
  96
  97     CachedMetadata(const char* data, size_t size)
  98     {
  99         // Serialized metadata should have non-empty data.
 100         ASSERT(size > dataStart);
 101
 102         m_serializedData.append(data, size);
 103     }
 104
 105     CachedMetadata(unsigned dataTypeID, const char* data, size_t size)
 106     {
 107         // Don't allow an ID of 0, it is used internally to indicate errors.
 108         ASSERT(dataTypeID);
 109         ASSERT(data);
 110
 111         appendUnsigned(dataTypeID);
 112         m_serializedData.append(data, size);
 113     }
 114
 115     // Serialization offsets. Format: [DATA_TYPE_ID][DATA].
 116     static const size_t dataTypeIDStart = 0;
 117     static const size_t dataStart = sizeof(unsigned);
 118
 119     // Since the serialization format supports random access, storing it in
 120     // serialized form avoids need for a copy during serialization.
 121     Vector<char> m_serializedData;
 122 };
 123
 124 }
 125
 126 #endif