OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/worker/worker_webkitplatformsupport_impl.h" | |
6 | |
7 #include "base/files/file_path.h" | |
8 #include "base/logging.h" | |
9 #include "base/message_loop/message_loop_proxy.h" | |
10 #include "base/strings/utf_string_conversions.h" | |
11 #include "content/child/blink_glue.h" | |
12 #include "content/child/database_util.h" | |
13 #include "content/child/fileapi/webfilesystem_impl.h" | |
14 #include "content/child/indexed_db/webidbfactory_impl.h" | |
15 #include "content/child/quota_dispatcher.h" | |
16 #include "content/child/quota_message_filter.h" | |
17 #include "content/child/thread_safe_sender.h" | |
18 #include "content/child/web_database_observer_impl.h" | |
19 #include "content/child/webblobregistry_impl.h" | |
20 #include "content/child/webfileutilities_impl.h" | |
21 #include "content/child/webmessageportchannel_impl.h" | |
22 #include "content/common/file_utilities_messages.h" | |
23 #include "content/common/mime_registry_messages.h" | |
24 #include "content/worker/worker_thread.h" | |
25 #include "ipc/ipc_sync_message_filter.h" | |
26 #include "net/base/mime_util.h" | |
27 #include "third_party/WebKit/public/platform/WebBlobRegistry.h" | |
28 #include "third_party/WebKit/public/platform/WebFileInfo.h" | |
29 #include "third_party/WebKit/public/platform/WebString.h" | |
30 #include "third_party/WebKit/public/platform/WebURL.h" | |
31 #include "webkit/common/quota/quota_types.h" | |
32 | |
33 using blink::Platform; | |
34 using blink::WebBlobRegistry; | |
35 using blink::WebClipboard; | |
36 using blink::WebFileInfo; | |
37 using blink::WebFileSystem; | |
38 using blink::WebFileUtilities; | |
39 using blink::WebMessagePortChannel; | |
40 using blink::WebMimeRegistry; | |
41 using blink::WebSandboxSupport; | |
42 using blink::WebStorageNamespace; | |
43 using blink::WebString; | |
44 using blink::WebURL; | |
45 | |
46 namespace content { | |
47 | |
48 // TODO(kinuko): Probably this could be consolidated into | |
49 // RendererWebKitPlatformSupportImpl::FileUtilities. | |
50 class WorkerWebKitPlatformSupportImpl::FileUtilities | |
51 : public WebFileUtilitiesImpl { | |
52 public: | |
53 explicit FileUtilities(ThreadSafeSender* sender) | |
54 : thread_safe_sender_(sender) {} | |
55 virtual bool getFileInfo(const WebString& path, WebFileInfo& result); | |
56 private: | |
57 scoped_refptr<ThreadSafeSender> thread_safe_sender_; | |
58 }; | |
59 | |
60 bool WorkerWebKitPlatformSupportImpl::FileUtilities::getFileInfo( | |
61 const WebString& path, | |
62 WebFileInfo& web_file_info) { | |
63 base::File::Info file_info; | |
64 base::File::Error status = base::File::FILE_ERROR_MAX; | |
65 if (!thread_safe_sender_.get() || | |
66 !thread_safe_sender_->Send(new FileUtilitiesMsg_GetFileInfo( | |
67 base::FilePath::FromUTF16Unsafe(path), &file_info, &status)) || | |
68 status != base::File::FILE_OK) { | |
69 return false; | |
70 } | |
71 FileInfoToWebFileInfo(file_info, &web_file_info); | |
72 web_file_info.platformPath = path; | |
73 return true; | |
74 } | |
75 | |
76 //------------------------------------------------------------------------------ | |
77 | |
78 WorkerWebKitPlatformSupportImpl::WorkerWebKitPlatformSupportImpl( | |
79 ThreadSafeSender* sender, | |
80 IPC::SyncMessageFilter* sync_message_filter, | |
81 QuotaMessageFilter* quota_message_filter) | |
82 : thread_safe_sender_(sender), | |
83 child_thread_loop_(base::MessageLoopProxy::current()), | |
84 sync_message_filter_(sync_message_filter), | |
85 quota_message_filter_(quota_message_filter) { | |
86 if (sender) { | |
87 blob_registry_.reset(new WebBlobRegistryImpl(sender)); | |
88 web_idb_factory_.reset(new WebIDBFactoryImpl(sender)); | |
89 web_database_observer_impl_.reset( | |
90 new WebDatabaseObserverImpl(sync_message_filter)); | |
91 } | |
92 } | |
93 | |
94 WorkerWebKitPlatformSupportImpl::~WorkerWebKitPlatformSupportImpl() { | |
95 WebFileSystemImpl::DeleteThreadSpecificInstance(); | |
96 } | |
97 | |
98 WebClipboard* WorkerWebKitPlatformSupportImpl::clipboard() { | |
99 NOTREACHED(); | |
100 return NULL; | |
101 } | |
102 | |
103 WebMimeRegistry* WorkerWebKitPlatformSupportImpl::mimeRegistry() { | |
104 return this; | |
105 } | |
106 | |
107 WebFileSystem* WorkerWebKitPlatformSupportImpl::fileSystem() { | |
108 return WebFileSystemImpl::ThreadSpecificInstance(child_thread_loop_.get()); | |
109 } | |
110 | |
111 WebFileUtilities* WorkerWebKitPlatformSupportImpl::fileUtilities() { | |
112 if (!file_utilities_) { | |
113 file_utilities_.reset(new FileUtilities(thread_safe_sender_.get())); | |
114 file_utilities_->set_sandbox_enabled(sandboxEnabled()); | |
115 } | |
116 return file_utilities_.get(); | |
117 } | |
118 | |
119 WebSandboxSupport* WorkerWebKitPlatformSupportImpl::sandboxSupport() { | |
120 NOTREACHED(); | |
121 return NULL; | |
122 } | |
123 | |
124 bool WorkerWebKitPlatformSupportImpl::sandboxEnabled() { | |
125 // Always return true because WebKit should always act as though the Sandbox | |
126 // is enabled for workers. See the comment in WebKitPlatformSupport for | |
127 // more info. | |
128 return true; | |
129 } | |
130 | |
131 unsigned long long WorkerWebKitPlatformSupportImpl::visitedLinkHash( | |
132 const char* canonical_url, | |
133 size_t length) { | |
134 NOTREACHED(); | |
135 return 0; | |
136 } | |
137 | |
138 bool WorkerWebKitPlatformSupportImpl::isLinkVisited( | |
139 unsigned long long link_hash) { | |
140 NOTREACHED(); | |
141 return false; | |
142 } | |
143 | |
144 void WorkerWebKitPlatformSupportImpl::createMessageChannel( | |
145 blink::WebMessagePortChannel** channel1, | |
146 blink::WebMessagePortChannel** channel2) { | |
147 WebMessagePortChannelImpl::CreatePair( | |
148 child_thread_loop_.get(), channel1, channel2); | |
149 } | |
150 | |
151 void WorkerWebKitPlatformSupportImpl::setCookies( | |
152 const WebURL& url, | |
153 const WebURL& first_party_for_cookies, | |
154 const WebString& value) { | |
155 NOTREACHED(); | |
156 } | |
157 | |
158 WebString WorkerWebKitPlatformSupportImpl::cookies( | |
159 const WebURL& url, const WebURL& first_party_for_cookies) { | |
160 // WebSocketHandshake may access cookies in worker process. | |
161 return WebString(); | |
162 } | |
163 | |
164 WebString WorkerWebKitPlatformSupportImpl::defaultLocale() { | |
165 NOTREACHED(); | |
166 return WebString(); | |
167 } | |
168 | |
169 WebStorageNamespace* | |
170 WorkerWebKitPlatformSupportImpl::createLocalStorageNamespace() { | |
171 NOTREACHED(); | |
172 return 0; | |
173 } | |
174 | |
175 void WorkerWebKitPlatformSupportImpl::dispatchStorageEvent( | |
176 const WebString& key, const WebString& old_value, | |
177 const WebString& new_value, const WebString& origin, | |
178 const blink::WebURL& url, bool is_local_storage) { | |
179 NOTREACHED(); | |
180 } | |
181 | |
182 Platform::FileHandle | |
183 WorkerWebKitPlatformSupportImpl::databaseOpenFile( | |
184 const WebString& vfs_file_name, int desired_flags) { | |
185 return DatabaseUtil::DatabaseOpenFile( | |
186 vfs_file_name, desired_flags, sync_message_filter_.get()); | |
187 } | |
188 | |
189 int WorkerWebKitPlatformSupportImpl::databaseDeleteFile( | |
190 const WebString& vfs_file_name, bool sync_dir) { | |
191 return DatabaseUtil::DatabaseDeleteFile( | |
192 vfs_file_name, sync_dir, sync_message_filter_.get()); | |
193 } | |
194 | |
195 long WorkerWebKitPlatformSupportImpl::databaseGetFileAttributes( | |
196 const WebString& vfs_file_name) { | |
197 return DatabaseUtil::DatabaseGetFileAttributes(vfs_file_name, | |
198 sync_message_filter_.get()); | |
199 } | |
200 | |
201 long long WorkerWebKitPlatformSupportImpl::databaseGetFileSize( | |
202 const WebString& vfs_file_name) { | |
203 return DatabaseUtil::DatabaseGetFileSize(vfs_file_name, | |
204 sync_message_filter_.get()); | |
205 } | |
206 | |
207 long long WorkerWebKitPlatformSupportImpl::databaseGetSpaceAvailableForOrigin( | |
208 const WebString& origin_identifier) { | |
209 return DatabaseUtil::DatabaseGetSpaceAvailable(origin_identifier, | |
210 sync_message_filter_.get()); | |
211 } | |
212 | |
213 blink::WebIDBFactory* WorkerWebKitPlatformSupportImpl::idbFactory() { | |
214 if (!web_idb_factory_) | |
215 web_idb_factory_.reset(new WebIDBFactoryImpl(thread_safe_sender_.get())); | |
216 return web_idb_factory_.get(); | |
217 } | |
218 | |
219 blink::WebDatabaseObserver* | |
220 WorkerWebKitPlatformSupportImpl::databaseObserver() { | |
221 return web_database_observer_impl_.get(); | |
222 } | |
223 | |
224 WebMimeRegistry::SupportsType | |
225 WorkerWebKitPlatformSupportImpl::supportsMIMEType( | |
226 const WebString&) { | |
227 return WebMimeRegistry::IsSupported; | |
228 } | |
229 | |
230 WebMimeRegistry::SupportsType | |
231 WorkerWebKitPlatformSupportImpl::supportsImageMIMEType( | |
232 const WebString&) { | |
233 NOTREACHED(); | |
234 return WebMimeRegistry::IsSupported; | |
235 } | |
236 | |
237 WebMimeRegistry::SupportsType | |
238 WorkerWebKitPlatformSupportImpl::supportsJavaScriptMIMEType(const WebString&) { | |
239 NOTREACHED(); | |
240 return WebMimeRegistry::IsSupported; | |
241 } | |
242 | |
243 WebMimeRegistry::SupportsType | |
244 WorkerWebKitPlatformSupportImpl::supportsMediaMIMEType( | |
245 const WebString&, const WebString&, const WebString&) { | |
246 NOTREACHED(); | |
247 return WebMimeRegistry::IsSupported; | |
248 } | |
249 | |
250 bool WorkerWebKitPlatformSupportImpl::supportsMediaSourceMIMEType( | |
251 const blink::WebString& mimeType, const blink::WebString& codecs) { | |
252 NOTREACHED(); | |
253 return false; | |
254 } | |
255 | |
256 bool WorkerWebKitPlatformSupportImpl::supportsEncryptedMediaMIMEType( | |
257 const blink::WebString& key_system, | |
258 const blink::WebString& mime_type, | |
259 const blink::WebString& codecs) { | |
260 NOTREACHED(); | |
261 return false; | |
262 } | |
263 | |
264 WebMimeRegistry::SupportsType | |
265 WorkerWebKitPlatformSupportImpl::supportsNonImageMIMEType( | |
266 const WebString&) { | |
267 NOTREACHED(); | |
268 return WebMimeRegistry::IsSupported; | |
269 } | |
270 | |
271 WebString WorkerWebKitPlatformSupportImpl::mimeTypeForExtension( | |
272 const WebString& file_extension) { | |
273 std::string mime_type; | |
274 thread_safe_sender_->Send(new MimeRegistryMsg_GetMimeTypeFromExtension( | |
275 base::FilePath::FromUTF16Unsafe(file_extension).value(), &mime_type)); | |
276 return base::ASCIIToUTF16(mime_type); | |
277 } | |
278 | |
279 WebString WorkerWebKitPlatformSupportImpl::wellKnownMimeTypeForExtension( | |
280 const WebString& file_extension) { | |
281 std::string mime_type; | |
282 net::GetWellKnownMimeTypeFromExtension( | |
283 base::FilePath::FromUTF16Unsafe(file_extension).value(), &mime_type); | |
284 return base::ASCIIToUTF16(mime_type); | |
285 } | |
286 | |
287 WebString WorkerWebKitPlatformSupportImpl::mimeTypeFromFile( | |
288 const WebString& file_path) { | |
289 std::string mime_type; | |
290 thread_safe_sender_->Send( | |
291 new MimeRegistryMsg_GetMimeTypeFromFile( | |
292 base::FilePath::FromUTF16Unsafe(file_path), | |
293 &mime_type)); | |
294 return base::ASCIIToUTF16(mime_type); | |
295 } | |
296 | |
297 WebBlobRegistry* WorkerWebKitPlatformSupportImpl::blobRegistry() { | |
298 return blob_registry_.get(); | |
299 } | |
300 | |
301 void WorkerWebKitPlatformSupportImpl::queryStorageUsageAndQuota( | |
302 const blink::WebURL& storage_partition, | |
303 blink::WebStorageQuotaType type, | |
304 blink::WebStorageQuotaCallbacks callbacks) { | |
305 if (!thread_safe_sender_.get() || !quota_message_filter_.get()) | |
306 return; | |
307 QuotaDispatcher::ThreadSpecificInstance( | |
308 thread_safe_sender_.get(), | |
309 quota_message_filter_.get())->QueryStorageUsageAndQuota( | |
310 storage_partition, | |
311 static_cast<quota::StorageType>(type), | |
312 QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks)); | |
313 } | |
314 | |
315 } // namespace content | |
OLD | NEW |