2010-08-30 Jian Li <jianli@chromium.org>
[WebKit-https.git] / WebCore / platform / network / BlobRegistryImpl.cpp
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 #include "config.h"
32
33 #if ENABLE(BLOB)
34
35 #include "BlobRegistryImpl.h"
36
37 #include "BlobResourceHandle.h"
38 #include "ResourceError.h"
39 #include "ResourceHandle.h"
40 #include "ResourceLoader.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 #if !PLATFORM(CHROMIUM)
49 BlobRegistry& blobRegistry()
50 {
51     ASSERT(isMainThread());
52     DEFINE_STATIC_LOCAL(BlobRegistryImpl, instance, ());
53     return instance;
54 }
55 #endif
56
57 bool BlobRegistryImpl::shouldLoadResource(const ResourceRequest& request) const
58 {
59     // If the resource is not fetched using the GET method, bail out.
60     if (!equalIgnoringCase(request.httpMethod(), "GET"))
61         return false;
62
63     return true;
64 }
65
66 PassRefPtr<ResourceHandle> BlobRegistryImpl::createResourceHandle(const ResourceRequest& request, ResourceHandleClient* client)
67 {
68     if (!shouldLoadResource(request))
69         return 0;
70
71     return BlobResourceHandle::create(m_blobs.get(request.url().string()), request, client);
72 }
73
74 bool BlobRegistryImpl::loadResourceSynchronously(const ResourceRequest& request, ResourceError& error, ResourceResponse& response, Vector<char>& data)
75 {
76     if (!shouldLoadResource(request))
77         return false;
78
79     BlobResourceHandle::loadResourceSynchronously(m_blobs.get(request.url().string()), request, error, response, data);
80     return true;
81 }
82
83 void BlobRegistryImpl::appendStorageItems(BlobStorageData* blobStorageData, const BlobDataItemList& items)
84 {
85     for (BlobDataItemList::const_iterator iter = items.begin(); iter != items.end(); ++iter) {
86         if (iter->type == BlobDataItem::Data)
87             blobStorageData->m_data.appendData(iter->data, iter->offset, iter->length);
88         else {
89             ASSERT(iter->type == BlobDataItem::File);
90             blobStorageData->m_data.appendFile(iter->path, iter->offset, iter->length, iter->expectedModificationTime);
91         }
92     }
93 }
94
95 void BlobRegistryImpl::appendStorageItems(BlobStorageData* blobStorageData, const BlobDataItemList& items, long long offset, long long length)
96 {
97     ASSERT(length != BlobDataItem::toEndOfFile);
98
99     BlobDataItemList::const_iterator iter = items.begin();
100     if (offset) {
101         for (; iter != items.end(); ++iter) {
102             if (offset >= iter->length)
103                 offset -= iter->length;
104             else
105                 break;
106         }
107     }
108
109     for (; iter != items.end() && length > 0; ++iter) {
110         long long currentLength = iter->length - offset;
111         long long newLength = currentLength > length ? length : currentLength;
112         if (iter->type == BlobDataItem::Data)
113             blobStorageData->m_data.appendData(iter->data, iter->offset + offset, newLength);
114         else {
115             ASSERT(iter->type == BlobDataItem::File);
116             blobStorageData->m_data.appendFile(iter->path, iter->offset + offset, newLength, iter->expectedModificationTime);
117         }
118         length -= newLength;
119         offset = 0;
120     }
121 }
122
123 void BlobRegistryImpl::registerBlobURL(const KURL& url, PassOwnPtr<BlobData> blobData)
124 {
125     ASSERT(isMainThread());
126
127     RefPtr<BlobStorageData> blobStorageData = BlobStorageData::create(blobData->contentType(), blobData->contentDisposition());
128
129     // The blob data is stored in the "canonical" way. That is, it only contains a list of Data and File items.
130     // 1) The Data item is denoted by the raw data and the range.
131     // 2) The File item is denoted by the file path, the range and the expected modification time.
132     // All the Blob items in the passing blob data are resolved and expanded into a set of Data and File items.
133
134     for (BlobDataItemList::const_iterator iter = blobData->items().begin(); iter != blobData->items().end(); ++iter) {
135         switch (iter->type) {
136         case BlobDataItem::Data:
137             blobStorageData->m_data.appendData(iter->data, 0, iter->data.length());
138             break;
139         case BlobDataItem::File:
140             blobStorageData->m_data.appendFile(iter->path, iter->offset, iter->length, iter->expectedModificationTime);
141             break;
142         case BlobDataItem::Blob:
143             if (m_blobs.contains(iter->url.string()))
144                 appendStorageItems(blobStorageData.get(), m_blobs.get(iter->url.string())->items(), iter->offset, iter->length);
145             break;
146         }
147     }
148
149     m_blobs.set(url.string(), blobStorageData);
150 }
151
152 void BlobRegistryImpl::registerBlobURL(const KURL& url, const KURL& srcURL)
153 {
154     ASSERT(isMainThread());
155
156     RefPtr<BlobStorageData> src = m_blobs.get(srcURL.string());
157     ASSERT(src);
158     if (!src)
159         return;
160
161     RefPtr<BlobStorageData> blobStorageData = BlobStorageData::create(src->contentType(), src->contentDisposition());
162     appendStorageItems(blobStorageData.get(), src->items());
163     
164     m_blobs.set(url.string(), blobStorageData);
165 }
166
167 void BlobRegistryImpl::unregisterBlobURL(const KURL& url)
168 {
169     ASSERT(isMainThread());
170     m_blobs.remove(url.string());
171 }
172
173 PassRefPtr<BlobStorageData> BlobRegistryImpl::getBlobDataFromURL(const KURL& url) const
174 {
175     ASSERT(isMainThread());
176     return m_blobs.get(url.string());
177 }
178
179 } // namespace WebCore
180
181 #endif // ENABLE(BLOB)