• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "platform/blob/BlobRegistry.h"
33 
34 #include "platform/blob/BlobData.h"
35 #include "platform/blob/BlobURL.h"
36 #include "platform/weborigin/SecurityOrigin.h"
37 #include "platform/weborigin/SecurityOriginCache.h"
38 #include "public/platform/Platform.h"
39 #include "public/platform/WebBlobData.h"
40 #include "public/platform/WebBlobRegistry.h"
41 #include "public/platform/WebString.h"
42 #include "public/platform/WebThreadSafeData.h"
43 #include "wtf/Assertions.h"
44 #include "wtf/HashMap.h"
45 #include "wtf/MainThread.h"
46 #include "wtf/RefPtr.h"
47 #include "wtf/ThreadSpecific.h"
48 #include "wtf/Threading.h"
49 #include "wtf/text/StringHash.h"
50 #include "wtf/text/WTFString.h"
51 
52 namespace blink {
53 
54 class BlobOriginCache : public SecurityOriginCache {
55 public:
56     BlobOriginCache();
57     virtual SecurityOrigin* cachedOrigin(const KURL&) OVERRIDE;
58 };
59 
60 struct BlobRegistryContext {
61     WTF_MAKE_FAST_ALLOCATED;
62 public:
BlobRegistryContextblink::BlobRegistryContext63     BlobRegistryContext(const KURL& url, PassOwnPtr<BlobData> blobData)
64         : url(url.copy())
65         , blobData(blobData)
66     {
67         this->blobData->detachFromCurrentThread();
68     }
69 
BlobRegistryContextblink::BlobRegistryContext70     BlobRegistryContext(const KURL& url, const String& type)
71         : url(url.copy())
72         , type(type.isolatedCopy())
73     {
74     }
75 
BlobRegistryContextblink::BlobRegistryContext76     BlobRegistryContext(const KURL& url, const KURL& srcURL)
77         : url(url.copy())
78         , srcURL(srcURL.copy())
79     {
80     }
81 
BlobRegistryContextblink::BlobRegistryContext82     BlobRegistryContext(const KURL& url, PassRefPtr<RawData> streamData)
83         : url(url.copy())
84         , streamData(streamData)
85     {
86     }
87 
BlobRegistryContextblink::BlobRegistryContext88     BlobRegistryContext(const KURL& url)
89         : url(url.copy())
90     {
91     }
92 
93     KURL url;
94     KURL srcURL;
95     OwnPtr<BlobData> blobData;
96     PassRefPtr<RawData> streamData;
97     String type;
98 };
99 
blobRegistry()100 static WebBlobRegistry* blobRegistry()
101 {
102     return Platform::current()->blobRegistry();
103 }
104 
105 typedef HashMap<String, RefPtr<SecurityOrigin> > BlobURLOriginMap;
originMap()106 static ThreadSpecific<BlobURLOriginMap>& originMap()
107 {
108     // We want to create the BlobOriginCache exactly once because it is shared by all the threads.
109     AtomicallyInitializedStatic(BlobOriginCache*, cache = new BlobOriginCache);
110     (void)cache; // BlobOriginCache's constructor does the interesting work.
111 
112     AtomicallyInitializedStatic(ThreadSpecific<BlobURLOriginMap>*, map = new ThreadSpecific<BlobURLOriginMap>);
113     return *map;
114 }
115 
saveToOriginMap(SecurityOrigin * origin,const KURL & url)116 static void saveToOriginMap(SecurityOrigin* origin, const KURL& url)
117 {
118     // If the blob URL contains null origin, as in the context with unique
119     // security origin or file URL, save the mapping between url and origin so
120     // that the origin can be retrived when doing security origin check.
121     if (origin && BlobURL::getOrigin(url) == "null")
122         originMap()->add(url.string(), origin);
123 }
124 
removeFromOriginMap(const KURL & url)125 static void removeFromOriginMap(const KURL& url)
126 {
127     if (BlobURL::getOrigin(url) == "null")
128         originMap()->remove(url.string());
129 }
130 
registerBlobData(const String & uuid,PassOwnPtr<BlobData> data)131 void BlobRegistry::registerBlobData(const String& uuid, PassOwnPtr<BlobData> data)
132 {
133     blobRegistry()->registerBlobData(uuid, WebBlobData(data));
134 }
135 
addBlobDataRef(const String & uuid)136 void BlobRegistry::addBlobDataRef(const String& uuid)
137 {
138     blobRegistry()->addBlobDataRef(uuid);
139 }
140 
removeBlobDataRef(const String & uuid)141 void BlobRegistry::removeBlobDataRef(const String& uuid)
142 {
143     blobRegistry()->removeBlobDataRef(uuid);
144 }
145 
registerPublicBlobURL(SecurityOrigin * origin,const KURL & url,PassRefPtr<BlobDataHandle> handle)146 void BlobRegistry::registerPublicBlobURL(SecurityOrigin* origin, const KURL& url, PassRefPtr<BlobDataHandle> handle)
147 {
148     saveToOriginMap(origin, url);
149     blobRegistry()->registerPublicBlobURL(url, handle->uuid());
150 }
151 
revokePublicBlobURL(const KURL & url)152 void BlobRegistry::revokePublicBlobURL(const KURL& url)
153 {
154     removeFromOriginMap(url);
155     blobRegistry()->revokePublicBlobURL(url);
156 }
157 
registerStreamURLTask(void * context)158 static void registerStreamURLTask(void* context)
159 {
160     OwnPtr<BlobRegistryContext> blobRegistryContext = adoptPtr(static_cast<BlobRegistryContext*>(context));
161     if (WebBlobRegistry* registry = blobRegistry())
162         registry->registerStreamURL(blobRegistryContext->url, blobRegistryContext->type);
163 }
164 
registerStreamURL(const KURL & url,const String & type)165 void BlobRegistry::registerStreamURL(const KURL& url, const String& type)
166 {
167     if (isMainThread()) {
168         if (WebBlobRegistry* registry = blobRegistry())
169             registry->registerStreamURL(url, type);
170     } else {
171         OwnPtr<BlobRegistryContext> context = adoptPtr(new BlobRegistryContext(url, type));
172         callOnMainThread(&registerStreamURLTask, context.leakPtr());
173     }
174 }
175 
registerStreamURLFromTask(void * context)176 static void registerStreamURLFromTask(void* context)
177 {
178     OwnPtr<BlobRegistryContext> blobRegistryContext = adoptPtr(static_cast<BlobRegistryContext*>(context));
179     if (WebBlobRegistry* registry = blobRegistry())
180         registry->registerStreamURL(blobRegistryContext->url, blobRegistryContext->srcURL);
181 }
182 
registerStreamURL(SecurityOrigin * origin,const KURL & url,const KURL & srcURL)183 void BlobRegistry::registerStreamURL(SecurityOrigin* origin, const KURL& url, const KURL& srcURL)
184 {
185     saveToOriginMap(origin, url);
186 
187     if (isMainThread()) {
188         if (WebBlobRegistry* registry = blobRegistry())
189             registry->registerStreamURL(url, srcURL);
190     } else {
191         OwnPtr<BlobRegistryContext> context = adoptPtr(new BlobRegistryContext(url, srcURL));
192         callOnMainThread(&registerStreamURLFromTask, context.leakPtr());
193     }
194 }
195 
addDataToStreamTask(void * context)196 static void addDataToStreamTask(void* context)
197 {
198     OwnPtr<BlobRegistryContext> blobRegistryContext = adoptPtr(static_cast<BlobRegistryContext*>(context));
199     if (WebBlobRegistry* registry = blobRegistry()) {
200         WebThreadSafeData webThreadSafeData(blobRegistryContext->streamData);
201         registry->addDataToStream(blobRegistryContext->url, webThreadSafeData);
202     }
203 }
204 
addDataToStream(const KURL & url,PassRefPtr<RawData> streamData)205 void BlobRegistry::addDataToStream(const KURL& url, PassRefPtr<RawData> streamData)
206 {
207     if (isMainThread()) {
208         if (WebBlobRegistry* registry = blobRegistry()) {
209             WebThreadSafeData webThreadSafeData(streamData);
210             registry->addDataToStream(url, webThreadSafeData);
211         }
212     } else {
213         OwnPtr<BlobRegistryContext> context = adoptPtr(new BlobRegistryContext(url, streamData));
214         callOnMainThread(&addDataToStreamTask, context.leakPtr());
215     }
216 }
217 
finalizeStreamTask(void * context)218 static void finalizeStreamTask(void* context)
219 {
220     OwnPtr<BlobRegistryContext> blobRegistryContext = adoptPtr(static_cast<BlobRegistryContext*>(context));
221     if (WebBlobRegistry* registry = blobRegistry())
222         registry->finalizeStream(blobRegistryContext->url);
223 }
224 
finalizeStream(const KURL & url)225 void BlobRegistry::finalizeStream(const KURL& url)
226 {
227     if (isMainThread()) {
228         if (WebBlobRegistry* registry = blobRegistry())
229             registry->finalizeStream(url);
230     } else {
231         OwnPtr<BlobRegistryContext> context = adoptPtr(new BlobRegistryContext(url));
232         callOnMainThread(&finalizeStreamTask, context.leakPtr());
233     }
234 }
235 
abortStreamTask(void * context)236 static void abortStreamTask(void* context)
237 {
238     OwnPtr<BlobRegistryContext> blobRegistryContext = adoptPtr(static_cast<BlobRegistryContext*>(context));
239     if (WebBlobRegistry* registry = blobRegistry())
240         registry->abortStream(blobRegistryContext->url);
241 }
242 
abortStream(const KURL & url)243 void BlobRegistry::abortStream(const KURL& url)
244 {
245     if (isMainThread()) {
246         if (WebBlobRegistry* registry = blobRegistry())
247             registry->abortStream(url);
248     } else {
249         OwnPtr<BlobRegistryContext> context = adoptPtr(new BlobRegistryContext(url));
250         callOnMainThread(&abortStreamTask, context.leakPtr());
251     }
252 }
253 
unregisterStreamURLTask(void * context)254 static void unregisterStreamURLTask(void* context)
255 {
256     OwnPtr<BlobRegistryContext> blobRegistryContext = adoptPtr(static_cast<BlobRegistryContext*>(context));
257     if (WebBlobRegistry* registry = blobRegistry())
258         registry->unregisterStreamURL(blobRegistryContext->url);
259 }
260 
unregisterStreamURL(const KURL & url)261 void BlobRegistry::unregisterStreamURL(const KURL& url)
262 {
263     removeFromOriginMap(url);
264 
265     if (isMainThread()) {
266         if (WebBlobRegistry* registry = blobRegistry())
267             registry->unregisterStreamURL(url);
268     } else {
269         OwnPtr<BlobRegistryContext> context = adoptPtr(new BlobRegistryContext(url));
270         callOnMainThread(&unregisterStreamURLTask, context.leakPtr());
271     }
272 }
273 
BlobOriginCache()274 BlobOriginCache::BlobOriginCache()
275 {
276     SecurityOrigin::setCache(this);
277 }
278 
cachedOrigin(const KURL & url)279 SecurityOrigin* BlobOriginCache::cachedOrigin(const KURL& url)
280 {
281     if (url.protocolIs("blob"))
282         return originMap()->get(url.string());
283     return 0;
284 }
285 
286 } // namespace blink
287