bc12849944a3df17ceb0347e7384ca2d4aae223b
[WebKit-https.git] / Source / WebCore / platform / network / BlobRegistryImpl.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  * Copyright (C) 2013 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "BlobRegistryImpl.h"
34
35 #if ENABLE(BLOB)
36
37 #include "BlobResourceHandle.h"
38 #include "BlobStorageData.h"
39 #include "ResourceError.h"
40 #include "ResourceHandle.h"
41 #include "ResourceRequest.h"
42 #include "ResourceResponse.h"
43 #include <wtf/MainThread.h>
44 #include <wtf/StdLibExtras.h>
45
46 namespace WebCore {
47
48 BlobRegistryImpl::~BlobRegistryImpl()
49 {
50 }
51
52 #if !PLATFORM(CHROMIUM)
53 static PassRefPtr<ResourceHandle> createResourceHandle(const ResourceRequest& request, ResourceHandleClient* client)
54 {
55     return static_cast<BlobRegistryImpl&>(blobRegistry()).createResourceHandle(request, client);
56 }
57
58 static void loadResourceSynchronously(NetworkingContext*, const ResourceRequest& request, StoredCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data)
59 {
60     BlobStorageData* blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromURL(request.url());
61     BlobResourceHandle::loadResourceSynchronously(blobData, request, error, response, data);
62 }
63
64 static void registerBlobResourceHandleConstructor()
65 {
66     static bool didRegister = false;
67     if (!didRegister) {
68         ResourceHandle::registerBuiltinConstructor("blob", createResourceHandle);
69         ResourceHandle::registerBuiltinSynchronousLoader("blob", loadResourceSynchronously);
70         didRegister = true;
71     }
72 }
73
74 #else
75
76 static void registerBlobResourceHandleConstructor()
77 {
78 }
79 #endif
80
81 PassRefPtr<ResourceHandle> BlobRegistryImpl::createResourceHandle(const ResourceRequest& request, ResourceHandleClient* client)
82 {
83     RefPtr<BlobResourceHandle> handle = BlobResourceHandle::createAsync(getBlobDataFromURL(request.url()), request, client);
84     if (!handle)
85         return 0;
86
87     handle->start();
88     return handle.release();
89 }
90
91 void BlobRegistryImpl::appendStorageItems(BlobStorageData* blobStorageData, const BlobDataItemList& items)
92 {
93     for (BlobDataItemList::const_iterator iter = items.begin(); iter != items.end(); ++iter) {
94         if (iter->type == BlobDataItem::Data)
95             blobStorageData->m_data.appendData(iter->data, iter->offset, iter->length);
96 #if ENABLE(FILE_SYSTEM)
97         else if (iter->type == BlobDataItem::URL)
98             blobStorageData->m_data.appendURL(iter->url, iter->offset, iter->length, iter->expectedModificationTime);
99 #endif
100         else {
101             ASSERT(iter->type == BlobDataItem::File);
102             blobStorageData->m_data.appendFile(iter->path, iter->offset, iter->length, iter->expectedModificationTime);
103         }
104     }
105 }
106
107 void BlobRegistryImpl::appendStorageItems(BlobStorageData* blobStorageData, const BlobDataItemList& items, long long offset, long long length)
108 {
109     ASSERT(length != BlobDataItem::toEndOfFile);
110
111     BlobDataItemList::const_iterator iter = items.begin();
112     if (offset) {
113         for (; iter != items.end(); ++iter) {
114             if (offset >= iter->length)
115                 offset -= iter->length;
116             else
117                 break;
118         }
119     }
120
121     for (; iter != items.end() && length > 0; ++iter) {
122         long long currentLength = iter->length - offset;
123         long long newLength = currentLength > length ? length : currentLength;
124         if (iter->type == BlobDataItem::Data)
125             blobStorageData->m_data.appendData(iter->data, iter->offset + offset, newLength);
126 #if ENABLE(FILE_SYSTEM)
127         else if (iter->type == BlobDataItem::URL)
128             blobStorageData->m_data.appendURL(iter->url, iter->offset + offset, newLength, iter->expectedModificationTime);
129 #endif
130         else {
131             ASSERT(iter->type == BlobDataItem::File);
132             blobStorageData->m_data.appendFile(iter->path, iter->offset + offset, newLength, iter->expectedModificationTime);
133         }
134         length -= newLength;
135         offset = 0;
136     }
137 }
138
139 void BlobRegistryImpl::registerBlobURL(const KURL& url, PassOwnPtr<BlobData> blobData)
140 {
141     ASSERT(isMainThread());
142     registerBlobResourceHandleConstructor();
143
144     RefPtr<BlobStorageData> blobStorageData = BlobStorageData::create(blobData->contentType(), blobData->contentDisposition());
145
146     // The blob data is stored in the "canonical" way. That is, it only contains a list of Data and File items.
147     // 1) The Data item is denoted by the raw data and the range.
148     // 2) The File item is denoted by the file path, the range and the expected modification time.
149     // 3) The URL item is denoted by the URL, the range and the expected modification time.
150     // All the Blob items in the passing blob data are resolved and expanded into a set of Data and File items.
151
152     for (BlobDataItemList::const_iterator iter = blobData->items().begin(); iter != blobData->items().end(); ++iter) {
153         switch (iter->type) {
154         case BlobDataItem::Data:
155             blobStorageData->m_data.appendData(iter->data, 0, iter->data->length());
156             break;
157         case BlobDataItem::File:
158             blobStorageData->m_data.appendFile(iter->path, iter->offset, iter->length, iter->expectedModificationTime);
159             break;
160 #if ENABLE(FILE_SYSTEM)
161         case BlobDataItem::URL:
162             blobStorageData->m_data.appendURL(iter->url, iter->offset, iter->length, iter->expectedModificationTime);
163             break;
164 #endif
165         case BlobDataItem::Blob:
166             if (m_blobs.contains(iter->url.string()))
167                 appendStorageItems(blobStorageData.get(), m_blobs.get(iter->url.string())->items(), iter->offset, iter->length);
168             break;
169         }
170     }
171
172     m_blobs.set(url.string(), blobStorageData);
173 }
174
175 void BlobRegistryImpl::registerBlobURL(const KURL& url, const KURL& srcURL)
176 {
177     ASSERT(isMainThread());
178     registerBlobResourceHandleConstructor();
179
180     RefPtr<BlobStorageData> src = m_blobs.get(srcURL.string());
181     ASSERT(src);
182     if (!src)
183         return;
184
185     m_blobs.set(url.string(), src);
186 }
187
188 void BlobRegistryImpl::unregisterBlobURL(const KURL& url)
189 {
190     ASSERT(isMainThread());
191     m_blobs.remove(url.string());
192 }
193
194 BlobStorageData* BlobRegistryImpl::getBlobDataFromURL(const KURL& url) const
195 {
196     ASSERT(isMainThread());
197     return m_blobs.get(url.string()).get();
198 }
199
200 } // namespace WebCore
201
202 #endif