Home | History | Annotate | Download | only in renderer 
      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:
    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:
    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 
    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 
    252 RendererWebKitPlatformSupportImpl::~RendererWebKitPlatformSupportImpl() {
    253   WebFileSystemImpl::DeleteThreadSpecificInstance();
    254 }
    255 
    256 //------------------------------------------------------------------------------
    257 
    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 
    266 blink::WebMimeRegistry* RendererWebKitPlatformSupportImpl::mimeRegistry() {
    267   return mime_registry_.get();
    268 }
    269 
    270 blink::WebFileUtilities*
    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 
    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 
    288 blink::WebCookieJar* RendererWebKitPlatformSupportImpl::cookieJar() {
    289   NOTREACHED() << "Use WebFrameClient::cookieJar() instead!";
    290   return NULL;
    291 }
    292 
    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 
    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 
    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 
    318 bool RendererWebKitPlatformSupportImpl::isLinkVisited(
    319     unsigned long long link_hash) {
    320   return GetContentClient()->renderer()->IsLinkVisited(link_hash);
    321 }
    322 
    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*
    331 RendererWebKitPlatformSupportImpl::prescientNetworking() {
    332   return GetContentClient()->renderer()->GetPrescientNetworking();
    333 }
    334 
    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 
    348 WebString RendererWebKitPlatformSupportImpl::defaultLocale() {
    349   return base::ASCIIToUTF16(RenderThread::Get()->GetLocale());
    350 }
    351 
    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*
    373 RendererWebKitPlatformSupportImpl::createLocalStorageNamespace() {
    374   return new WebStorageNamespaceImpl();
    375 }
    376 
    377 
    378 //------------------------------------------------------------------------------
    379 
    380 WebIDBFactory* RendererWebKitPlatformSupportImpl::idbFactory() {
    381   return web_idb_factory_.get();
    382 }
    383 
    384 //------------------------------------------------------------------------------
    385 
    386 WebFileSystem* RendererWebKitPlatformSupportImpl::fileSystem() {
    387   return WebFileSystemImpl::ThreadSpecificInstance(child_thread_loop_.get());
    388 }
    389 
    390 //------------------------------------------------------------------------------
    391 
    392 WebMimeRegistry::SupportsType
    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
    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
    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
    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 
    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 
    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::
    526 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 
    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 
    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
    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
    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
    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 
    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 
    629 long RendererWebKitPlatformSupportImpl::databaseGetFileAttributes(
    630     const WebString& vfs_file_name) {
    631   return DatabaseUtil::DatabaseGetFileAttributes(vfs_file_name,
    632                                                  sync_message_filter_.get());
    633 }
    634 
    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 
    641 long long RendererWebKitPlatformSupportImpl::databaseGetSpaceAvailableForOrigin(
    642     const WebString& origin_identifier) {
    643   return DatabaseUtil::DatabaseGetSpaceAvailable(origin_identifier,
    644                                                  sync_message_filter_.get());
    645 }
    646 
    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 
    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 
    663 double RendererWebKitPlatformSupportImpl::audioHardwareSampleRate() {
    664   RenderThreadImpl* thread = RenderThreadImpl::current();
    665   return thread->GetAudioHardwareConfig()->GetOutputSampleRate();
    666 }
    667 
    668 size_t RendererWebKitPlatformSupportImpl::audioHardwareBufferSize() {
    669   RenderThreadImpl* thread = RenderThreadImpl::current();
    670   return thread->GetAudioHardwareConfig()->GetOutputBufferSize();
    671 }
    672 
    673 unsigned RendererWebKitPlatformSupportImpl::audioHardwareOutputChannels() {
    674   RenderThreadImpl* thread = RenderThreadImpl::current();
    675   return thread->GetAudioHardwareConfig()->GetOutputChannels();
    676 }
    677 
    678 WebDatabaseObserver* RendererWebKitPlatformSupportImpl::databaseObserver() {
    679   return web_database_observer_impl_.get();
    680 }
    681 
    682 WebAudioDevice*
    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)
    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
    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*
    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 
    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*
    813 RendererWebKitPlatformSupportImpl::publicSuffixList() {
    814   return &public_suffix_list_;
    815 }
    816 
    817 //------------------------------------------------------------------------------
    818 
    819 blink::WebString
    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 
    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*
    857     RendererWebKitPlatformSupportImpl::scrollbarBehavior() {
    858   return web_scrollbar_behavior_.get();
    859 }
    860 
    861 //------------------------------------------------------------------------------
    862 
    863 WebBlobRegistry* RendererWebKitPlatformSupportImpl::blobRegistry() {
    864   // blob_registry_ can be NULL when running some tests.
    865   return blob_registry_.get();
    866 }
    867 
    868 //------------------------------------------------------------------------------
    869 
    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*
    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*
    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
    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*
    926 RendererWebKitPlatformSupportImpl::createSpeechSynthesizer(
    927     blink::WebSpeechSynthesizerClient* client) {
    928   return GetContentClient()->renderer()->OverrideSpeechSynthesizer(client);
    929 }
    930 
    931 //------------------------------------------------------------------------------
    932 
    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*
    943 RendererWebKitPlatformSupportImpl::createOffscreenGraphicsContext3D(
    944     const blink::WebGraphicsContext3D::Attributes& attributes) {
    945   return createOffscreenGraphicsContext3D(attributes, NULL);
    946 }
    947 
    948 blink::WebGraphicsContext3D*
    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::
    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*
   1000 RendererWebKitPlatformSupportImpl::compositorSupport() {
   1001   return &compositor_support_;
   1002 }
   1003 
   1004 //------------------------------------------------------------------------------
   1005 
   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
   1015 void RendererWebKitPlatformSupportImpl::SetMockDeviceLightDataForTesting(
   1016     double data) {
   1017   g_test_device_light_data = data;
   1018 }
   1019 
   1020 //------------------------------------------------------------------------------
   1021 
   1022 // static
   1023 void RendererWebKitPlatformSupportImpl::SetMockDeviceMotionDataForTesting(
   1024     const blink::WebDeviceMotionData& data) {
   1025   g_test_device_motion_data.Get() = data;
   1026 }
   1027 
   1028 //------------------------------------------------------------------------------
   1029 
   1030 // static
   1031 void RendererWebKitPlatformSupportImpl::SetMockDeviceOrientationDataForTesting(
   1032     const blink::WebDeviceOrientationData& data) {
   1033   g_test_device_orientation_data.Get() = data;
   1034 }
   1035 
   1036 //------------------------------------------------------------------------------
   1037 
   1038 void RendererWebKitPlatformSupportImpl::vibrate(unsigned int milliseconds) {
   1039   RenderThread::Get()->Send(
   1040       new ViewHostMsg_Vibrate(base::checked_cast<int64>(milliseconds)));
   1041 }
   1042 
   1043 void RendererWebKitPlatformSupportImpl::cancelVibration() {
   1044   RenderThread::Get()->Send(new ViewHostMsg_CancelVibration());
   1045 }
   1046 
   1047 //------------------------------------------------------------------------------
   1048 
   1049 // static
   1050 PlatformEventObserverBase*
   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 
   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 
   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 
   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 
   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 
   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 
   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