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/renderer/renderer_webkitplatformsupport_impl.h"
6
7 #include "base/command_line.h"
8 #include "base/files/file_path.h"
9 #include "base/lazy_instance.h"
10 #include "base/logging.h"
11 #include "base/memory/shared_memory.h"
12 #include "base/message_loop/message_loop_proxy.h"
13 #include "base/metrics/histogram.h"
14 #include "base/numerics/safe_conversions.h"
15 #include "base/strings/string_number_conversions.h"
16 #include "base/strings/utf_string_conversions.h"
17 #include "content/child/database_util.h"
18 #include "content/child/file_info_util.h"
19 #include "content/child/fileapi/webfilesystem_impl.h"
20 #include "content/child/indexed_db/webidbfactory_impl.h"
21 #include "content/child/npapi/npobject_util.h"
22 #include "content/child/quota_dispatcher.h"
23 #include "content/child/quota_message_filter.h"
24 #include "content/child/simple_webmimeregistry_impl.h"
25 #include "content/child/thread_safe_sender.h"
26 #include "content/child/web_database_observer_impl.h"
27 #include "content/child/webblobregistry_impl.h"
28 #include "content/child/webfileutilities_impl.h"
29 #include "content/child/webmessageportchannel_impl.h"
30 #include "content/common/file_utilities_messages.h"
31 #include "content/common/gpu/client/context_provider_command_buffer.h"
32 #include "content/common/gpu/client/gpu_channel_host.h"
33 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
34 #include "content/common/gpu/gpu_process_launch_causes.h"
35 #include "content/common/mime_registry_messages.h"
36 #include "content/common/view_messages.h"
37 #include "content/public/common/content_switches.h"
38 #include "content/public/common/webplugininfo.h"
39 #include "content/public/renderer/content_renderer_client.h"
40 #include "content/renderer/battery_status/battery_status_dispatcher.h"
41 #include "content/renderer/device_sensors/device_light_event_pump.h"
42 #include "content/renderer/device_sensors/device_motion_event_pump.h"
43 #include "content/renderer/device_sensors/device_orientation_event_pump.h"
44 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
45 #include "content/renderer/gamepad_shared_memory_reader.h"
46 #include "content/renderer/media/audio_decoder.h"
47 #include "content/renderer/media/crypto/key_systems.h"
48 #include "content/renderer/media/renderer_webaudiodevice_impl.h"
49 #include "content/renderer/media/renderer_webmidiaccessor_impl.h"
50 #include "content/renderer/media/webcontentdecryptionmodule_impl.h"
51 #include "content/renderer/render_thread_impl.h"
52 #include "content/renderer/renderer_clipboard_client.h"
53 #include "content/renderer/screen_orientation/screen_orientation_observer.h"
54 #include "content/renderer/webclipboard_impl.h"
55 #include "content/renderer/webgraphicscontext3d_provider_impl.h"
56 #include "content/renderer/webpublicsuffixlist_impl.h"
57 #include "gpu/config/gpu_info.h"
58 #include "ipc/ipc_sync_message_filter.h"
59 #include "media/audio/audio_output_device.h"
60 #include "media/base/audio_hardware_config.h"
61 #include "media/filters/stream_parser_factory.h"
62 #include "net/base/mime_util.h"
63 #include "net/base/net_util.h"
64 #include "storage/common/quota/quota_types.h"
65 #include "third_party/WebKit/public/platform/WebBatteryStatusListener.h"
66 #include "third_party/WebKit/public/platform/WebBlobRegistry.h"
67 #include "third_party/WebKit/public/platform/WebDeviceLightListener.h"
68 #include "third_party/WebKit/public/platform/WebDeviceMotionListener.h"
69 #include "third_party/WebKit/public/platform/WebDeviceOrientationListener.h"
70 #include "third_party/WebKit/public/platform/WebFileInfo.h"
71 #include "third_party/WebKit/public/platform/WebGamepads.h"
72 #include "third_party/WebKit/public/platform/WebMediaStreamCenter.h"
73 #include "third_party/WebKit/public/platform/WebMediaStreamCenterClient.h"
74 #include "third_party/WebKit/public/platform/WebPluginListBuilder.h"
75 #include "third_party/WebKit/public/platform/WebURL.h"
76 #include "third_party/WebKit/public/platform/WebVector.h"
77 #include "ui/gfx/color_profile.h"
78 #include "url/gurl.h"
79 #include "webkit/common/gpu/context_provider_web_context.h"
80
81 #if defined(OS_ANDROID)
82 #include "content/renderer/android/synchronous_compositor_factory.h"
83 #include "content/renderer/media/android/audio_decoder_android.h"
84 #endif
85
86 #if defined(OS_MACOSX)
87 #include "content/common/mac/font_descriptor.h"
88 #include "content/common/mac/font_loader.h"
89 #include "content/renderer/webscrollbarbehavior_impl_mac.h"
90 #include "third_party/WebKit/public/platform/mac/WebSandboxSupport.h"
91 #endif
92
93 #if defined(OS_POSIX)
94 #include "base/file_descriptor_posix.h"
95 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
96 #include <map>
97 #include <string>
98
99 #include "base/synchronization/lock.h"
100 #include "content/common/child_process_sandbox_support_impl_linux.h"
101 #include "third_party/WebKit/public/platform/linux/WebFallbackFont.h"
102 #include "third_party/WebKit/public/platform/linux/WebSandboxSupport.h"
103 #include "third_party/icu/source/common/unicode/utf16.h"
104 #endif
105 #endif
106
107 #if defined(OS_WIN)
108 #include "content/common/child_process_messages.h"
109 #include "third_party/WebKit/public/platform/win/WebSandboxSupport.h"
110 #endif
111
112 #if defined(USE_AURA)
113 #include "content/renderer/webscrollbarbehavior_impl_gtkoraura.h"
114 #elif !defined(OS_MACOSX)
115 #include "third_party/WebKit/public/platform/WebScrollbarBehavior.h"
116 #define WebScrollbarBehaviorImpl blink::WebScrollbarBehavior
117 #endif
118
119 #if defined(ENABLE_WEBRTC)
120 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
121 #endif
122
123 using blink::Platform;
124 using blink::WebAudioDevice;
125 using blink::WebBlobRegistry;
126 using blink::WebDatabaseObserver;
127 using blink::WebFileInfo;
128 using blink::WebFileSystem;
129 using blink::WebGamepad;
130 using blink::WebGamepads;
131 using blink::WebIDBFactory;
132 using blink::WebMIDIAccessor;
133 using blink::WebMediaStreamCenter;
134 using blink::WebMediaStreamCenterClient;
135 using blink::WebMimeRegistry;
136 using blink::WebRTCPeerConnectionHandler;
137 using blink::WebRTCPeerConnectionHandlerClient;
138 using blink::WebStorageNamespace;
139 using blink::WebString;
140 using blink::WebURL;
141 using blink::WebVector;
142
143 namespace content {
144
145 namespace {
146
147 bool g_sandbox_enabled = true;
148 double g_test_device_light_data = -1;
149 base::LazyInstance<blink::WebDeviceMotionData>::Leaky
150 g_test_device_motion_data = LAZY_INSTANCE_INITIALIZER;
151 base::LazyInstance<blink::WebDeviceOrientationData>::Leaky
152 g_test_device_orientation_data = LAZY_INSTANCE_INITIALIZER;
153
154 } // namespace
155
156 //------------------------------------------------------------------------------
157
158 class RendererWebKitPlatformSupportImpl::MimeRegistry
159 : public SimpleWebMimeRegistryImpl {
160 public:
161 virtual blink::WebMimeRegistry::SupportsType supportsMediaMIMEType(
162 const blink::WebString& mime_type,
163 const blink::WebString& codecs,
164 const blink::WebString& key_system);
165 virtual bool supportsMediaSourceMIMEType(const blink::WebString& mime_type,
166 const blink::WebString& codecs);
167 virtual bool supportsEncryptedMediaMIMEType(const WebString& key_system,
168 const WebString& mime_type,
169 const WebString& codecs) OVERRIDE;
170 virtual blink::WebString mimeTypeForExtension(
171 const blink::WebString& file_extension);
172 virtual blink::WebString mimeTypeFromFile(
173 const blink::WebString& file_path);
174 };
175
176 class RendererWebKitPlatformSupportImpl::FileUtilities
177 : public WebFileUtilitiesImpl {
178 public:
FileUtilities(ThreadSafeSender * sender)179 explicit FileUtilities(ThreadSafeSender* sender)
180 : thread_safe_sender_(sender) {}
181 virtual bool getFileInfo(const WebString& path, WebFileInfo& result);
182 private:
183 bool SendSyncMessageFromAnyThread(IPC::SyncMessage* msg) const;
184 scoped_refptr<ThreadSafeSender> thread_safe_sender_;
185 };
186
187 #if defined(OS_ANDROID)
188 // WebKit doesn't use WebSandboxSupport on android so we don't need to
189 // implement anything here.
190 class RendererWebKitPlatformSupportImpl::SandboxSupport {
191 };
192 #else
193 class RendererWebKitPlatformSupportImpl::SandboxSupport
194 : public blink::WebSandboxSupport {
195 public:
~SandboxSupport()196 virtual ~SandboxSupport() {}
197
198 #if defined(OS_WIN)
199 virtual bool ensureFontLoaded(HFONT);
200 #elif defined(OS_MACOSX)
201 virtual bool loadFont(
202 NSFont* src_font,
203 CGFontRef* container,
204 uint32* font_id);
205 #elif defined(OS_POSIX)
206 virtual void getFallbackFontForCharacter(
207 blink::WebUChar32 character,
208 const char* preferred_locale,
209 blink::WebFallbackFont* fallbackFont);
210 virtual void getRenderStyleForStrike(
211 const char* family, int sizeAndStyle, blink::WebFontRenderStyle* out);
212
213 private:
214 // WebKit likes to ask us for the correct font family to use for a set of
215 // unicode code points. It needs this information frequently so we cache it
216 // here.
217 base::Lock unicode_font_families_mutex_;
218 std::map<int32_t, blink::WebFallbackFont> unicode_font_families_;
219 #endif
220 };
221 #endif // defined(OS_ANDROID)
222
223 //------------------------------------------------------------------------------
224
RendererWebKitPlatformSupportImpl()225 RendererWebKitPlatformSupportImpl::RendererWebKitPlatformSupportImpl()
226 : clipboard_client_(new RendererClipboardClient),
227 clipboard_(new WebClipboardImpl(clipboard_client_.get())),
228 mime_registry_(new RendererWebKitPlatformSupportImpl::MimeRegistry),
229 sudden_termination_disables_(0),
230 plugin_refresh_allowed_(true),
231 child_thread_loop_(base::MessageLoopProxy::current()),
232 web_scrollbar_behavior_(new WebScrollbarBehaviorImpl) {
233 if (g_sandbox_enabled && sandboxEnabled()) {
234 sandbox_support_.reset(
235 new RendererWebKitPlatformSupportImpl::SandboxSupport);
236 } else {
237 DVLOG(1) << "Disabling sandbox support for testing.";
238 }
239
240 // ChildThread may not exist in some tests.
241 if (ChildThread::current()) {
242 sync_message_filter_ = ChildThread::current()->sync_message_filter();
243 thread_safe_sender_ = ChildThread::current()->thread_safe_sender();
244 quota_message_filter_ = ChildThread::current()->quota_message_filter();
245 blob_registry_.reset(new WebBlobRegistryImpl(thread_safe_sender_.get()));
246 web_idb_factory_.reset(new WebIDBFactoryImpl(thread_safe_sender_.get()));
247 web_database_observer_impl_.reset(
248 new WebDatabaseObserverImpl(sync_message_filter_.get()));
249 }
250 }
251
~RendererWebKitPlatformSupportImpl()252 RendererWebKitPlatformSupportImpl::~RendererWebKitPlatformSupportImpl() {
253 WebFileSystemImpl::DeleteThreadSpecificInstance();
254 }
255
256 //------------------------------------------------------------------------------
257
clipboard()258 blink::WebClipboard* RendererWebKitPlatformSupportImpl::clipboard() {
259 blink::WebClipboard* clipboard =
260 GetContentClient()->renderer()->OverrideWebClipboard();
261 if (clipboard)
262 return clipboard;
263 return clipboard_.get();
264 }
265
mimeRegistry()266 blink::WebMimeRegistry* RendererWebKitPlatformSupportImpl::mimeRegistry() {
267 return mime_registry_.get();
268 }
269
270 blink::WebFileUtilities*
fileUtilities()271 RendererWebKitPlatformSupportImpl::fileUtilities() {
272 if (!file_utilities_) {
273 file_utilities_.reset(new FileUtilities(thread_safe_sender_.get()));
274 file_utilities_->set_sandbox_enabled(sandboxEnabled());
275 }
276 return file_utilities_.get();
277 }
278
sandboxSupport()279 blink::WebSandboxSupport* RendererWebKitPlatformSupportImpl::sandboxSupport() {
280 #if defined(OS_ANDROID)
281 // WebKit doesn't use WebSandboxSupport on android.
282 return NULL;
283 #else
284 return sandbox_support_.get();
285 #endif
286 }
287
cookieJar()288 blink::WebCookieJar* RendererWebKitPlatformSupportImpl::cookieJar() {
289 NOTREACHED() << "Use WebFrameClient::cookieJar() instead!";
290 return NULL;
291 }
292
themeEngine()293 blink::WebThemeEngine* RendererWebKitPlatformSupportImpl::themeEngine() {
294 blink::WebThemeEngine* theme_engine =
295 GetContentClient()->renderer()->OverrideThemeEngine();
296 if (theme_engine)
297 return theme_engine;
298 return BlinkPlatformImpl::themeEngine();
299 }
300
sandboxEnabled()301 bool RendererWebKitPlatformSupportImpl::sandboxEnabled() {
302 // As explained in Platform.h, this function is used to decide
303 // whether to allow file system operations to come out of WebKit or not.
304 // Even if the sandbox is disabled, there's no reason why the code should
305 // act any differently...unless we're in single process mode. In which
306 // case, we have no other choice. Platform.h discourages using
307 // this switch unless absolutely necessary, so hopefully we won't end up
308 // with too many code paths being different in single-process mode.
309 return !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
310 }
311
visitedLinkHash(const char * canonical_url,size_t length)312 unsigned long long RendererWebKitPlatformSupportImpl::visitedLinkHash(
313 const char* canonical_url,
314 size_t length) {
315 return GetContentClient()->renderer()->VisitedLinkHash(canonical_url, length);
316 }
317
isLinkVisited(unsigned long long link_hash)318 bool RendererWebKitPlatformSupportImpl::isLinkVisited(
319 unsigned long long link_hash) {
320 return GetContentClient()->renderer()->IsLinkVisited(link_hash);
321 }
322
createMessageChannel(blink::WebMessagePortChannel ** channel1,blink::WebMessagePortChannel ** channel2)323 void RendererWebKitPlatformSupportImpl::createMessageChannel(
324 blink::WebMessagePortChannel** channel1,
325 blink::WebMessagePortChannel** channel2) {
326 WebMessagePortChannelImpl::CreatePair(
327 child_thread_loop_.get(), channel1, channel2);
328 }
329
330 blink::WebPrescientNetworking*
prescientNetworking()331 RendererWebKitPlatformSupportImpl::prescientNetworking() {
332 return GetContentClient()->renderer()->GetPrescientNetworking();
333 }
334
cacheMetadata(const blink::WebURL & url,double response_time,const char * data,size_t size)335 void RendererWebKitPlatformSupportImpl::cacheMetadata(
336 const blink::WebURL& url,
337 double response_time,
338 const char* data,
339 size_t size) {
340 // Let the browser know we generated cacheable metadata for this resource. The
341 // browser may cache it and return it on subsequent responses to speed
342 // the processing of this resource.
343 std::vector<char> copy(data, data + size);
344 RenderThread::Get()->Send(
345 new ViewHostMsg_DidGenerateCacheableMetadata(url, response_time, copy));
346 }
347
defaultLocale()348 WebString RendererWebKitPlatformSupportImpl::defaultLocale() {
349 return base::ASCIIToUTF16(RenderThread::Get()->GetLocale());
350 }
351
suddenTerminationChanged(bool enabled)352 void RendererWebKitPlatformSupportImpl::suddenTerminationChanged(bool enabled) {
353 if (enabled) {
354 // We should not get more enables than disables, but we want it to be a
355 // non-fatal error if it does happen.
356 DCHECK_GT(sudden_termination_disables_, 0);
357 sudden_termination_disables_ = std::max(sudden_termination_disables_ - 1,
358 0);
359 if (sudden_termination_disables_ != 0)
360 return;
361 } else {
362 sudden_termination_disables_++;
363 if (sudden_termination_disables_ != 1)
364 return;
365 }
366
367 RenderThread* thread = RenderThread::Get();
368 if (thread) // NULL in unittests.
369 thread->Send(new ViewHostMsg_SuddenTerminationChanged(enabled));
370 }
371
372 WebStorageNamespace*
createLocalStorageNamespace()373 RendererWebKitPlatformSupportImpl::createLocalStorageNamespace() {
374 return new WebStorageNamespaceImpl();
375 }
376
377
378 //------------------------------------------------------------------------------
379
idbFactory()380 WebIDBFactory* RendererWebKitPlatformSupportImpl::idbFactory() {
381 return web_idb_factory_.get();
382 }
383
384 //------------------------------------------------------------------------------
385
fileSystem()386 WebFileSystem* RendererWebKitPlatformSupportImpl::fileSystem() {
387 return WebFileSystemImpl::ThreadSpecificInstance(child_thread_loop_.get());
388 }
389
390 //------------------------------------------------------------------------------
391
392 WebMimeRegistry::SupportsType
supportsMediaMIMEType(const WebString & mime_type,const WebString & codecs,const WebString & key_system)393 RendererWebKitPlatformSupportImpl::MimeRegistry::supportsMediaMIMEType(
394 const WebString& mime_type,
395 const WebString& codecs,
396 const WebString& key_system) {
397 const std::string mime_type_ascii = ToASCIIOrEmpty(mime_type);
398 // Not supporting the container is a flat-out no.
399 if (!net::IsSupportedMediaMimeType(mime_type_ascii))
400 return IsNotSupported;
401
402 if (!key_system.isEmpty()) {
403 // Check whether the key system is supported with the mime_type and codecs.
404
405 // Chromium only supports ASCII parameters.
406 if (!base::IsStringASCII(key_system))
407 return IsNotSupported;
408
409 std::string key_system_ascii =
410 GetUnprefixedKeySystemName(base::UTF16ToASCII(key_system));
411 std::vector<std::string> strict_codecs;
412 net::ParseCodecString(ToASCIIOrEmpty(codecs), &strict_codecs, true);
413
414 if (!IsSupportedKeySystemWithMediaMimeType(
415 mime_type_ascii, strict_codecs, key_system_ascii)) {
416 return IsNotSupported;
417 }
418
419 // Continue processing the mime_type and codecs.
420 }
421
422 // Check list of strict codecs to see if it is supported.
423 if (net::IsStrictMediaMimeType(mime_type_ascii)) {
424 // Check if the codecs are a perfect match.
425 std::vector<std::string> strict_codecs;
426 net::ParseCodecString(ToASCIIOrEmpty(codecs), &strict_codecs, false);
427 return static_cast<WebMimeRegistry::SupportsType> (
428 net::IsSupportedStrictMediaMimeType(mime_type_ascii, strict_codecs));
429 }
430
431 // If we don't recognize the codec, it's possible we support it.
432 std::vector<std::string> parsed_codecs;
433 net::ParseCodecString(ToASCIIOrEmpty(codecs), &parsed_codecs, true);
434 if (!net::AreSupportedMediaCodecs(parsed_codecs))
435 return MayBeSupported;
436
437 // Otherwise we have a perfect match.
438 return IsSupported;
439 }
440
441 bool
supportsMediaSourceMIMEType(const blink::WebString & mime_type,const WebString & codecs)442 RendererWebKitPlatformSupportImpl::MimeRegistry::supportsMediaSourceMIMEType(
443 const blink::WebString& mime_type,
444 const WebString& codecs) {
445 const std::string mime_type_ascii = ToASCIIOrEmpty(mime_type);
446 std::vector<std::string> parsed_codec_ids;
447 net::ParseCodecString(ToASCIIOrEmpty(codecs), &parsed_codec_ids, false);
448 if (mime_type_ascii.empty())
449 return false;
450 return media::StreamParserFactory::IsTypeSupported(
451 mime_type_ascii, parsed_codec_ids);
452 }
453
454 bool
supportsEncryptedMediaMIMEType(const WebString & key_system,const WebString & mime_type,const WebString & codecs)455 RendererWebKitPlatformSupportImpl::MimeRegistry::supportsEncryptedMediaMIMEType(
456 const WebString& key_system,
457 const WebString& mime_type,
458 const WebString& codecs) {
459 // Chromium only supports ASCII parameters.
460 if (!base::IsStringASCII(key_system) || !base::IsStringASCII(mime_type) ||
461 !base::IsStringASCII(codecs)) {
462 return false;
463 }
464
465 if (key_system.isEmpty())
466 return false;
467
468 const std::string mime_type_ascii = base::UTF16ToASCII(mime_type);
469
470 std::vector<std::string> codec_vector;
471 bool strip_suffix = !net::IsStrictMediaMimeType(mime_type_ascii);
472 net::ParseCodecString(base::UTF16ToASCII(codecs), &codec_vector,
473 strip_suffix);
474
475 return IsSupportedKeySystemWithMediaMimeType(
476 mime_type_ascii, codec_vector, base::UTF16ToASCII(key_system));
477 }
478
479 WebString
mimeTypeForExtension(const WebString & file_extension)480 RendererWebKitPlatformSupportImpl::MimeRegistry::mimeTypeForExtension(
481 const WebString& file_extension) {
482 if (IsPluginProcess())
483 return SimpleWebMimeRegistryImpl::mimeTypeForExtension(file_extension);
484
485 // The sandbox restricts our access to the registry, so we need to proxy
486 // these calls over to the browser process.
487 std::string mime_type;
488 RenderThread::Get()->Send(
489 new MimeRegistryMsg_GetMimeTypeFromExtension(
490 base::FilePath::FromUTF16Unsafe(file_extension).value(), &mime_type));
491 return base::ASCIIToUTF16(mime_type);
492 }
493
mimeTypeFromFile(const WebString & file_path)494 WebString RendererWebKitPlatformSupportImpl::MimeRegistry::mimeTypeFromFile(
495 const WebString& file_path) {
496 if (IsPluginProcess())
497 return SimpleWebMimeRegistryImpl::mimeTypeFromFile(file_path);
498
499 // The sandbox restricts our access to the registry, so we need to proxy
500 // these calls over to the browser process.
501 std::string mime_type;
502 RenderThread::Get()->Send(new MimeRegistryMsg_GetMimeTypeFromFile(
503 base::FilePath::FromUTF16Unsafe(file_path),
504 &mime_type));
505 return base::ASCIIToUTF16(mime_type);
506 }
507
508 //------------------------------------------------------------------------------
509
getFileInfo(const WebString & path,WebFileInfo & web_file_info)510 bool RendererWebKitPlatformSupportImpl::FileUtilities::getFileInfo(
511 const WebString& path,
512 WebFileInfo& web_file_info) {
513 base::File::Info file_info;
514 base::File::Error status = base::File::FILE_ERROR_MAX;
515 if (!SendSyncMessageFromAnyThread(new FileUtilitiesMsg_GetFileInfo(
516 base::FilePath::FromUTF16Unsafe(path), &file_info, &status)) ||
517 status != base::File::FILE_OK) {
518 return false;
519 }
520 FileInfoToWebFileInfo(file_info, &web_file_info);
521 web_file_info.platformPath = path;
522 return true;
523 }
524
525 bool RendererWebKitPlatformSupportImpl::FileUtilities::
SendSyncMessageFromAnyThread(IPC::SyncMessage * msg) const526 SendSyncMessageFromAnyThread(IPC::SyncMessage* msg) const {
527 base::TimeTicks begin = base::TimeTicks::Now();
528 const bool success = thread_safe_sender_->Send(msg);
529 base::TimeDelta delta = base::TimeTicks::Now() - begin;
530 UMA_HISTOGRAM_TIMES("RendererSyncIPC.ElapsedTime", delta);
531 return success;
532 }
533
534 //------------------------------------------------------------------------------
535
536 #if defined(OS_WIN)
537
ensureFontLoaded(HFONT font)538 bool RendererWebKitPlatformSupportImpl::SandboxSupport::ensureFontLoaded(
539 HFONT font) {
540 LOGFONT logfont;
541 GetObject(font, sizeof(LOGFONT), &logfont);
542 RenderThread::Get()->PreCacheFont(logfont);
543 return true;
544 }
545
546 #elif defined(OS_MACOSX)
547
loadFont(NSFont * src_font,CGFontRef * out,uint32 * font_id)548 bool RendererWebKitPlatformSupportImpl::SandboxSupport::loadFont(
549 NSFont* src_font, CGFontRef* out, uint32* font_id) {
550 uint32 font_data_size;
551 FontDescriptor src_font_descriptor(src_font);
552 base::SharedMemoryHandle font_data;
553 if (!RenderThread::Get()->Send(new ViewHostMsg_LoadFont(
554 src_font_descriptor, &font_data_size, &font_data, font_id))) {
555 *out = NULL;
556 *font_id = 0;
557 return false;
558 }
559
560 if (font_data_size == 0 || font_data == base::SharedMemory::NULLHandle() ||
561 *font_id == 0) {
562 LOG(ERROR) << "Bad response from ViewHostMsg_LoadFont() for " <<
563 src_font_descriptor.font_name;
564 *out = NULL;
565 *font_id = 0;
566 return false;
567 }
568
569 // TODO(jeremy): Need to call back into WebKit to make sure that the font
570 // isn't already activated, based on the font id. If it's already
571 // activated, don't reactivate it here - crbug.com/72727 .
572
573 return FontLoader::CGFontRefFromBuffer(font_data, font_data_size, out);
574 }
575
576 #elif defined(OS_ANDROID)
577
578 // WebKit doesn't use WebSandboxSupport on android so we don't need to
579 // implement anything here. This is cleaner to support than excluding the
580 // whole class for android.
581
582 #elif defined(OS_POSIX)
583
584 void
getFallbackFontForCharacter(blink::WebUChar32 character,const char * preferred_locale,blink::WebFallbackFont * fallbackFont)585 RendererWebKitPlatformSupportImpl::SandboxSupport::getFallbackFontForCharacter(
586 blink::WebUChar32 character,
587 const char* preferred_locale,
588 blink::WebFallbackFont* fallbackFont) {
589 base::AutoLock lock(unicode_font_families_mutex_);
590 const std::map<int32_t, blink::WebFallbackFont>::const_iterator iter =
591 unicode_font_families_.find(character);
592 if (iter != unicode_font_families_.end()) {
593 fallbackFont->name = iter->second.name;
594 fallbackFont->filename = iter->second.filename;
595 fallbackFont->fontconfigInterfaceId = iter->second.fontconfigInterfaceId;
596 fallbackFont->ttcIndex = iter->second.ttcIndex;
597 fallbackFont->isBold = iter->second.isBold;
598 fallbackFont->isItalic = iter->second.isItalic;
599 return;
600 }
601
602 GetFallbackFontForCharacter(character, preferred_locale, fallbackFont);
603 unicode_font_families_.insert(std::make_pair(character, *fallbackFont));
604 }
605
606 void
getRenderStyleForStrike(const char * family,int sizeAndStyle,blink::WebFontRenderStyle * out)607 RendererWebKitPlatformSupportImpl::SandboxSupport::getRenderStyleForStrike(
608 const char* family, int sizeAndStyle, blink::WebFontRenderStyle* out) {
609 GetRenderStyleForStrike(family, sizeAndStyle, out);
610 }
611
612 #endif
613
614 //------------------------------------------------------------------------------
615
616 Platform::FileHandle
databaseOpenFile(const WebString & vfs_file_name,int desired_flags)617 RendererWebKitPlatformSupportImpl::databaseOpenFile(
618 const WebString& vfs_file_name, int desired_flags) {
619 return DatabaseUtil::DatabaseOpenFile(
620 vfs_file_name, desired_flags, sync_message_filter_.get());
621 }
622
databaseDeleteFile(const WebString & vfs_file_name,bool sync_dir)623 int RendererWebKitPlatformSupportImpl::databaseDeleteFile(
624 const WebString& vfs_file_name, bool sync_dir) {
625 return DatabaseUtil::DatabaseDeleteFile(
626 vfs_file_name, sync_dir, sync_message_filter_.get());
627 }
628
databaseGetFileAttributes(const WebString & vfs_file_name)629 long RendererWebKitPlatformSupportImpl::databaseGetFileAttributes(
630 const WebString& vfs_file_name) {
631 return DatabaseUtil::DatabaseGetFileAttributes(vfs_file_name,
632 sync_message_filter_.get());
633 }
634
databaseGetFileSize(const WebString & vfs_file_name)635 long long RendererWebKitPlatformSupportImpl::databaseGetFileSize(
636 const WebString& vfs_file_name) {
637 return DatabaseUtil::DatabaseGetFileSize(vfs_file_name,
638 sync_message_filter_.get());
639 }
640
databaseGetSpaceAvailableForOrigin(const WebString & origin_identifier)641 long long RendererWebKitPlatformSupportImpl::databaseGetSpaceAvailableForOrigin(
642 const WebString& origin_identifier) {
643 return DatabaseUtil::DatabaseGetSpaceAvailable(origin_identifier,
644 sync_message_filter_.get());
645 }
646
canAccelerate2dCanvas()647 bool RendererWebKitPlatformSupportImpl::canAccelerate2dCanvas() {
648 RenderThreadImpl* thread = RenderThreadImpl::current();
649 GpuChannelHost* host = thread->EstablishGpuChannelSync(
650 CAUSE_FOR_GPU_LAUNCH_CANVAS_2D);
651 if (!host)
652 return false;
653
654 return host->gpu_info().SupportsAccelerated2dCanvas();
655 }
656
isThreadedCompositingEnabled()657 bool RendererWebKitPlatformSupportImpl::isThreadedCompositingEnabled() {
658 RenderThreadImpl* thread = RenderThreadImpl::current();
659 // thread can be NULL in tests.
660 return thread && thread->compositor_message_loop_proxy().get();
661 }
662
audioHardwareSampleRate()663 double RendererWebKitPlatformSupportImpl::audioHardwareSampleRate() {
664 RenderThreadImpl* thread = RenderThreadImpl::current();
665 return thread->GetAudioHardwareConfig()->GetOutputSampleRate();
666 }
667
audioHardwareBufferSize()668 size_t RendererWebKitPlatformSupportImpl::audioHardwareBufferSize() {
669 RenderThreadImpl* thread = RenderThreadImpl::current();
670 return thread->GetAudioHardwareConfig()->GetOutputBufferSize();
671 }
672
audioHardwareOutputChannels()673 unsigned RendererWebKitPlatformSupportImpl::audioHardwareOutputChannels() {
674 RenderThreadImpl* thread = RenderThreadImpl::current();
675 return thread->GetAudioHardwareConfig()->GetOutputChannels();
676 }
677
databaseObserver()678 WebDatabaseObserver* RendererWebKitPlatformSupportImpl::databaseObserver() {
679 return web_database_observer_impl_.get();
680 }
681
682 WebAudioDevice*
createAudioDevice(size_t buffer_size,unsigned input_channels,unsigned channels,double sample_rate,WebAudioDevice::RenderCallback * callback,const blink::WebString & input_device_id)683 RendererWebKitPlatformSupportImpl::createAudioDevice(
684 size_t buffer_size,
685 unsigned input_channels,
686 unsigned channels,
687 double sample_rate,
688 WebAudioDevice::RenderCallback* callback,
689 const blink::WebString& input_device_id) {
690 // Use a mock for testing.
691 blink::WebAudioDevice* mock_device =
692 GetContentClient()->renderer()->OverrideCreateAudioDevice(sample_rate);
693 if (mock_device)
694 return mock_device;
695
696 // The |channels| does not exactly identify the channel layout of the
697 // device. The switch statement below assigns a best guess to the channel
698 // layout based on number of channels.
699 // TODO(crogers): WebKit should give the channel layout instead of the hard
700 // channel count.
701 media::ChannelLayout layout = media::CHANNEL_LAYOUT_UNSUPPORTED;
702 switch (channels) {
703 case 1:
704 layout = media::CHANNEL_LAYOUT_MONO;
705 break;
706 case 2:
707 layout = media::CHANNEL_LAYOUT_STEREO;
708 break;
709 case 3:
710 layout = media::CHANNEL_LAYOUT_2_1;
711 break;
712 case 4:
713 layout = media::CHANNEL_LAYOUT_4_0;
714 break;
715 case 5:
716 layout = media::CHANNEL_LAYOUT_5_0;
717 break;
718 case 6:
719 layout = media::CHANNEL_LAYOUT_5_1;
720 break;
721 case 7:
722 layout = media::CHANNEL_LAYOUT_7_0;
723 break;
724 case 8:
725 layout = media::CHANNEL_LAYOUT_7_1;
726 break;
727 default:
728 layout = media::CHANNEL_LAYOUT_STEREO;
729 }
730
731 int session_id = 0;
732 if (input_device_id.isNull() ||
733 !base::StringToInt(base::UTF16ToUTF8(input_device_id), &session_id)) {
734 if (input_channels > 0)
735 DLOG(WARNING) << "createAudioDevice(): request for audio input ignored";
736
737 input_channels = 0;
738 }
739
740 media::AudioParameters params(
741 media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
742 layout, static_cast<int>(sample_rate), 16, buffer_size,
743 media::AudioParameters::NO_EFFECTS);
744
745 return new RendererWebAudioDeviceImpl(params, callback, session_id);
746 }
747
748 #if defined(OS_ANDROID)
loadAudioResource(blink::WebAudioBus * destination_bus,const char * audio_file_data,size_t data_size)749 bool RendererWebKitPlatformSupportImpl::loadAudioResource(
750 blink::WebAudioBus* destination_bus, const char* audio_file_data,
751 size_t data_size) {
752 return DecodeAudioFileData(destination_bus,
753 audio_file_data,
754 data_size,
755 thread_safe_sender_);
756 }
757 #else
loadAudioResource(blink::WebAudioBus * destination_bus,const char * audio_file_data,size_t data_size)758 bool RendererWebKitPlatformSupportImpl::loadAudioResource(
759 blink::WebAudioBus* destination_bus, const char* audio_file_data,
760 size_t data_size) {
761 return DecodeAudioFileData(
762 destination_bus, audio_file_data, data_size);
763 }
764 #endif // defined(OS_ANDROID)
765
766 //------------------------------------------------------------------------------
767
768 blink::WebMIDIAccessor*
createMIDIAccessor(blink::WebMIDIAccessorClient * client)769 RendererWebKitPlatformSupportImpl::createMIDIAccessor(
770 blink::WebMIDIAccessorClient* client) {
771 blink::WebMIDIAccessor* accessor =
772 GetContentClient()->renderer()->OverrideCreateMIDIAccessor(client);
773 if (accessor)
774 return accessor;
775
776 return new RendererWebMIDIAccessorImpl(client);
777 }
778
getPluginList(bool refresh,blink::WebPluginListBuilder * builder)779 void RendererWebKitPlatformSupportImpl::getPluginList(
780 bool refresh,
781 blink::WebPluginListBuilder* builder) {
782 #if defined(ENABLE_PLUGINS)
783 std::vector<WebPluginInfo> plugins;
784 if (!plugin_refresh_allowed_)
785 refresh = false;
786 RenderThread::Get()->Send(
787 new ViewHostMsg_GetPlugins(refresh, &plugins));
788 for (size_t i = 0; i < plugins.size(); ++i) {
789 const WebPluginInfo& plugin = plugins[i];
790
791 builder->addPlugin(
792 plugin.name, plugin.desc,
793 plugin.path.BaseName().AsUTF16Unsafe());
794
795 for (size_t j = 0; j < plugin.mime_types.size(); ++j) {
796 const WebPluginMimeType& mime_type = plugin.mime_types[j];
797
798 builder->addMediaTypeToLastPlugin(
799 WebString::fromUTF8(mime_type.mime_type), mime_type.description);
800
801 for (size_t k = 0; k < mime_type.file_extensions.size(); ++k) {
802 builder->addFileExtensionToLastMediaType(
803 WebString::fromUTF8(mime_type.file_extensions[k]));
804 }
805 }
806 }
807 #endif
808 }
809
810 //------------------------------------------------------------------------------
811
812 blink::WebPublicSuffixList*
publicSuffixList()813 RendererWebKitPlatformSupportImpl::publicSuffixList() {
814 return &public_suffix_list_;
815 }
816
817 //------------------------------------------------------------------------------
818
819 blink::WebString
signedPublicKeyAndChallengeString(unsigned key_size_index,const blink::WebString & challenge,const blink::WebURL & url)820 RendererWebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
821 unsigned key_size_index,
822 const blink::WebString& challenge,
823 const blink::WebURL& url) {
824 std::string signed_public_key;
825 RenderThread::Get()->Send(new ViewHostMsg_Keygen(
826 static_cast<uint32>(key_size_index),
827 challenge.utf8(),
828 GURL(url),
829 &signed_public_key));
830 return WebString::fromUTF8(signed_public_key);
831 }
832
833 //------------------------------------------------------------------------------
834
screenColorProfile(WebVector<char> * to_profile)835 void RendererWebKitPlatformSupportImpl::screenColorProfile(
836 WebVector<char>* to_profile) {
837 #if defined(OS_WIN)
838 // On Windows screen color profile is only available in the browser.
839 std::vector<char> profile;
840 // This Send() can be called from any impl-side thread. Use a thread
841 // safe send to avoid crashing trying to access RenderThread::Get(),
842 // which is not accessible from arbitrary threads.
843 thread_safe_sender_->Send(
844 new ViewHostMsg_GetMonitorColorProfile(&profile));
845 *to_profile = profile;
846 #else
847 // On other platforms, the primary monitor color profile can be read
848 // directly.
849 gfx::ColorProfile profile;
850 *to_profile = profile.profile();
851 #endif
852 }
853
854 //------------------------------------------------------------------------------
855
856 blink::WebScrollbarBehavior*
scrollbarBehavior()857 RendererWebKitPlatformSupportImpl::scrollbarBehavior() {
858 return web_scrollbar_behavior_.get();
859 }
860
861 //------------------------------------------------------------------------------
862
blobRegistry()863 WebBlobRegistry* RendererWebKitPlatformSupportImpl::blobRegistry() {
864 // blob_registry_ can be NULL when running some tests.
865 return blob_registry_.get();
866 }
867
868 //------------------------------------------------------------------------------
869
sampleGamepads(WebGamepads & gamepads)870 void RendererWebKitPlatformSupportImpl::sampleGamepads(WebGamepads& gamepads) {
871 PlatformEventObserverBase* observer =
872 platform_event_observers_.Lookup(blink::WebPlatformEventGamepad);
873 if (!observer)
874 return;
875 static_cast<RendererGamepadProvider*>(observer)->SampleGamepads(gamepads);
876 }
877
878 //------------------------------------------------------------------------------
879
880 WebRTCPeerConnectionHandler*
createRTCPeerConnectionHandler(WebRTCPeerConnectionHandlerClient * client)881 RendererWebKitPlatformSupportImpl::createRTCPeerConnectionHandler(
882 WebRTCPeerConnectionHandlerClient* client) {
883 RenderThreadImpl* render_thread = RenderThreadImpl::current();
884 DCHECK(render_thread);
885 if (!render_thread)
886 return NULL;
887
888 #if defined(ENABLE_WEBRTC)
889 WebRTCPeerConnectionHandler* peer_connection_handler =
890 GetContentClient()->renderer()->OverrideCreateWebRTCPeerConnectionHandler(
891 client);
892 if (peer_connection_handler)
893 return peer_connection_handler;
894
895 PeerConnectionDependencyFactory* rtc_dependency_factory =
896 render_thread->GetPeerConnectionDependencyFactory();
897 return rtc_dependency_factory->CreateRTCPeerConnectionHandler(client);
898 #else
899 return NULL;
900 #endif // defined(ENABLE_WEBRTC)
901 }
902
903 //------------------------------------------------------------------------------
904
905 WebMediaStreamCenter*
createMediaStreamCenter(WebMediaStreamCenterClient * client)906 RendererWebKitPlatformSupportImpl::createMediaStreamCenter(
907 WebMediaStreamCenterClient* client) {
908 RenderThreadImpl* render_thread = RenderThreadImpl::current();
909 DCHECK(render_thread);
910 if (!render_thread)
911 return NULL;
912 return render_thread->CreateMediaStreamCenter(client);
913 }
914
915 // static
SetSandboxEnabledForTesting(bool enable)916 bool RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(
917 bool enable) {
918 bool was_enabled = g_sandbox_enabled;
919 g_sandbox_enabled = enable;
920 return was_enabled;
921 }
922
923 //------------------------------------------------------------------------------
924
925 blink::WebSpeechSynthesizer*
createSpeechSynthesizer(blink::WebSpeechSynthesizerClient * client)926 RendererWebKitPlatformSupportImpl::createSpeechSynthesizer(
927 blink::WebSpeechSynthesizerClient* client) {
928 return GetContentClient()->renderer()->OverrideSpeechSynthesizer(client);
929 }
930
931 //------------------------------------------------------------------------------
932
processMemorySizesInBytes(size_t * private_bytes,size_t * shared_bytes)933 bool RendererWebKitPlatformSupportImpl::processMemorySizesInBytes(
934 size_t* private_bytes, size_t* shared_bytes) {
935 content::RenderThread::Get()->Send(
936 new ViewHostMsg_GetProcessMemorySizes(private_bytes, shared_bytes));
937 return true;
938 }
939
940 //------------------------------------------------------------------------------
941
942 blink::WebGraphicsContext3D*
createOffscreenGraphicsContext3D(const blink::WebGraphicsContext3D::Attributes & attributes)943 RendererWebKitPlatformSupportImpl::createOffscreenGraphicsContext3D(
944 const blink::WebGraphicsContext3D::Attributes& attributes) {
945 return createOffscreenGraphicsContext3D(attributes, NULL);
946 }
947
948 blink::WebGraphicsContext3D*
createOffscreenGraphicsContext3D(const blink::WebGraphicsContext3D::Attributes & attributes,blink::WebGraphicsContext3D * share_context)949 RendererWebKitPlatformSupportImpl::createOffscreenGraphicsContext3D(
950 const blink::WebGraphicsContext3D::Attributes& attributes,
951 blink::WebGraphicsContext3D* share_context) {
952 if (!RenderThreadImpl::current())
953 return NULL;
954
955 scoped_ptr<webkit::gpu::WebGraphicsContext3DImpl> context;
956 bool must_use_synchronous_factory = false;
957 #if defined(OS_ANDROID)
958 if (SynchronousCompositorFactory* factory =
959 SynchronousCompositorFactory::GetInstance()) {
960 context.reset(factory->CreateOffscreenGraphicsContext3D(attributes));
961 must_use_synchronous_factory = true;
962 }
963 #endif
964 if (!must_use_synchronous_factory) {
965 scoped_refptr<GpuChannelHost> gpu_channel_host(
966 RenderThreadImpl::current()->EstablishGpuChannelSync(
967 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE));
968
969 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
970 bool lose_context_when_out_of_memory = false;
971 context.reset(WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
972 gpu_channel_host.get(),
973 attributes,
974 lose_context_when_out_of_memory,
975 GURL(attributes.topDocumentURL),
976 limits,
977 static_cast<WebGraphicsContext3DCommandBufferImpl*>(share_context)));
978 }
979 // Most likely the GPU process exited and the attempt to reconnect to it
980 // failed. Need to try to restore the context again later.
981 if (!context || !context->InitializeOnCurrentThread())
982 return NULL;
983 return context.release();
984 }
985
986 //------------------------------------------------------------------------------
987
988 blink::WebGraphicsContext3DProvider* RendererWebKitPlatformSupportImpl::
createSharedOffscreenGraphicsContext3DProvider()989 createSharedOffscreenGraphicsContext3DProvider() {
990 scoped_refptr<webkit::gpu::ContextProviderWebContext> provider =
991 RenderThreadImpl::current()->SharedMainThreadContextProvider();
992 if (!provider.get())
993 return NULL;
994 return new WebGraphicsContext3DProviderImpl(provider);
995 }
996
997 //------------------------------------------------------------------------------
998
999 blink::WebCompositorSupport*
compositorSupport()1000 RendererWebKitPlatformSupportImpl::compositorSupport() {
1001 return &compositor_support_;
1002 }
1003
1004 //------------------------------------------------------------------------------
1005
convertIDNToUnicode(const blink::WebString & host,const blink::WebString & languages)1006 blink::WebString RendererWebKitPlatformSupportImpl::convertIDNToUnicode(
1007 const blink::WebString& host,
1008 const blink::WebString& languages) {
1009 return net::IDNToUnicode(host.utf8(), languages.utf8());
1010 }
1011
1012 //------------------------------------------------------------------------------
1013
1014 // static
SetMockDeviceLightDataForTesting(double data)1015 void RendererWebKitPlatformSupportImpl::SetMockDeviceLightDataForTesting(
1016 double data) {
1017 g_test_device_light_data = data;
1018 }
1019
1020 //------------------------------------------------------------------------------
1021
1022 // static
SetMockDeviceMotionDataForTesting(const blink::WebDeviceMotionData & data)1023 void RendererWebKitPlatformSupportImpl::SetMockDeviceMotionDataForTesting(
1024 const blink::WebDeviceMotionData& data) {
1025 g_test_device_motion_data.Get() = data;
1026 }
1027
1028 //------------------------------------------------------------------------------
1029
1030 // static
SetMockDeviceOrientationDataForTesting(const blink::WebDeviceOrientationData & data)1031 void RendererWebKitPlatformSupportImpl::SetMockDeviceOrientationDataForTesting(
1032 const blink::WebDeviceOrientationData& data) {
1033 g_test_device_orientation_data.Get() = data;
1034 }
1035
1036 //------------------------------------------------------------------------------
1037
vibrate(unsigned int milliseconds)1038 void RendererWebKitPlatformSupportImpl::vibrate(unsigned int milliseconds) {
1039 RenderThread::Get()->Send(
1040 new ViewHostMsg_Vibrate(base::checked_cast<int64>(milliseconds)));
1041 }
1042
cancelVibration()1043 void RendererWebKitPlatformSupportImpl::cancelVibration() {
1044 RenderThread::Get()->Send(new ViewHostMsg_CancelVibration());
1045 }
1046
1047 //------------------------------------------------------------------------------
1048
1049 // static
1050 PlatformEventObserverBase*
CreatePlatformEventObserverFromType(blink::WebPlatformEventType type)1051 RendererWebKitPlatformSupportImpl::CreatePlatformEventObserverFromType(
1052 blink::WebPlatformEventType type) {
1053 RenderThread* thread = RenderThreadImpl::current();
1054
1055 // When running layout tests, those observers should not listen to the actual
1056 // hardware changes. In order to make that happen, they will receive a null
1057 // thread.
1058 if (thread && RenderThreadImpl::current()->layout_test_mode())
1059 thread = 0;
1060
1061 switch (type) {
1062 case blink::WebPlatformEventDeviceMotion: {
1063 return new DeviceMotionEventPump(thread);
1064 }
1065 case blink::WebPlatformEventDeviceOrientation: {
1066 return new DeviceOrientationEventPump(thread);
1067 }
1068 case blink::WebPlatformEventDeviceLight: {
1069 return new DeviceLightEventPump(thread);
1070 }
1071 case blink::WebPlatformEventBattery: {
1072 return new BatteryStatusDispatcher(thread);
1073 }
1074 case blink::WebPlatformEventGamepad:
1075 return new GamepadSharedMemoryReader(thread);
1076 break;
1077 case blink::WebPlatformEventScreenOrientation:
1078 return new ScreenOrientationObserver();
1079 default:
1080 // A default statement is required to prevent compilation errors when Blink
1081 // adds a new type.
1082 VLOG(1) << "RendererWebKitPlatformSupportImpl::startListening() with "
1083 "unknown type.";
1084 }
1085
1086 return 0;
1087 }
1088
SetPlatformEventObserverForTesting(blink::WebPlatformEventType type,scoped_ptr<PlatformEventObserverBase> observer)1089 void RendererWebKitPlatformSupportImpl::SetPlatformEventObserverForTesting(
1090 blink::WebPlatformEventType type,
1091 scoped_ptr<PlatformEventObserverBase> observer) {
1092 if (platform_event_observers_.Lookup(type))
1093 platform_event_observers_.Remove(type);
1094 platform_event_observers_.AddWithID(observer.release(), type);
1095 }
1096
startListening(blink::WebPlatformEventType type,blink::WebPlatformEventListener * listener)1097 void RendererWebKitPlatformSupportImpl::startListening(
1098 blink::WebPlatformEventType type,
1099 blink::WebPlatformEventListener* listener) {
1100 PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
1101 if (!observer) {
1102 observer = CreatePlatformEventObserverFromType(type);
1103 if (!observer)
1104 return;
1105 platform_event_observers_.AddWithID(observer, static_cast<int32>(type));
1106 }
1107 observer->Start(listener);
1108
1109 // Device events (motion, orientation and light) expect to get an event fired
1110 // as soon as a listener is registered if a fake data was passed before.
1111 // TODO(mlamouri,timvolodine): make those send mock values directly instead of
1112 // using this broken pattern.
1113 if (RenderThreadImpl::current() &&
1114 RenderThreadImpl::current()->layout_test_mode() &&
1115 (type == blink::WebPlatformEventDeviceMotion ||
1116 type == blink::WebPlatformEventDeviceOrientation ||
1117 type == blink::WebPlatformEventDeviceLight)) {
1118 SendFakeDeviceEventDataForTesting(type);
1119 }
1120 }
1121
SendFakeDeviceEventDataForTesting(blink::WebPlatformEventType type)1122 void RendererWebKitPlatformSupportImpl::SendFakeDeviceEventDataForTesting(
1123 blink::WebPlatformEventType type) {
1124 PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
1125 CHECK(observer);
1126
1127 void* data = 0;
1128
1129 switch (type) {
1130 case blink::WebPlatformEventDeviceMotion:
1131 if (!(g_test_device_motion_data == 0))
1132 data = &g_test_device_motion_data.Get();
1133 break;
1134 case blink::WebPlatformEventDeviceOrientation:
1135 if (!(g_test_device_orientation_data == 0))
1136 data = &g_test_device_orientation_data.Get();
1137 break;
1138 case blink::WebPlatformEventDeviceLight:
1139 if (g_test_device_light_data >= 0)
1140 data = &g_test_device_light_data;
1141 break;
1142 default:
1143 NOTREACHED();
1144 break;
1145 }
1146
1147 if (!data)
1148 return;
1149
1150 base::MessageLoopProxy::current()->PostTask(
1151 FROM_HERE,
1152 base::Bind(&PlatformEventObserverBase::SendFakeDataForTesting,
1153 base::Unretained(observer), data));
1154 }
1155
stopListening(blink::WebPlatformEventType type)1156 void RendererWebKitPlatformSupportImpl::stopListening(
1157 blink::WebPlatformEventType type) {
1158 PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
1159 if (!observer)
1160 return;
1161 observer->Stop();
1162 }
1163
1164 //------------------------------------------------------------------------------
1165
queryStorageUsageAndQuota(const blink::WebURL & storage_partition,blink::WebStorageQuotaType type,blink::WebStorageQuotaCallbacks callbacks)1166 void RendererWebKitPlatformSupportImpl::queryStorageUsageAndQuota(
1167 const blink::WebURL& storage_partition,
1168 blink::WebStorageQuotaType type,
1169 blink::WebStorageQuotaCallbacks callbacks) {
1170 if (!thread_safe_sender_.get() || !quota_message_filter_.get())
1171 return;
1172 QuotaDispatcher::ThreadSpecificInstance(thread_safe_sender_.get(),
1173 quota_message_filter_.get())
1174 ->QueryStorageUsageAndQuota(
1175 storage_partition,
1176 static_cast<storage::StorageType>(type),
1177 QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
1178 }
1179
1180 //------------------------------------------------------------------------------
1181
MockBatteryStatusChangedForTesting(const blink::WebBatteryStatus & status)1182 void RendererWebKitPlatformSupportImpl::MockBatteryStatusChangedForTesting(
1183 const blink::WebBatteryStatus& status) {
1184 PlatformEventObserverBase* observer =
1185 platform_event_observers_.Lookup(blink::WebPlatformEventBattery);
1186 if (!observer)
1187 return;
1188 observer->SendFakeDataForTesting((void*)&status);
1189 }
1190
1191 } // namespace content
1192