RTCCertificate, RTCPeerConnection.generateCertificate (WebRTC JavaScript) added.

content/renderer/renderer_blink_platform_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/renderer_blink_platform_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
@@ skipping 42 matching lines @@
 #include "content/renderer/cache_storage/webserviceworkercachestorage_impl.h"
 #include "content/renderer/device_sensors/device_light_event_pump.h"
 #include "content/renderer/device_sensors/device_motion_event_pump.h"
 #include "content/renderer/device_sensors/device_orientation_event_pump.h"
 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
 #include "content/renderer/gamepad_shared_memory_reader.h"
 #include "content/renderer/media/audio_decoder.h"
 #include "content/renderer/media/media_recorder_handler.h"
 #include "content/renderer/media/renderer_webaudiodevice_impl.h"
 #include "content/renderer/media/renderer_webmidiaccessor_impl.h"
+#include "content/renderer/media/rtc_certificate_generator.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_clipboard_delegate.h"
 #include "content/renderer/screen_orientation/screen_orientation_observer.h"
 #include "content/renderer/webclipboard_impl.h"
 #include "content/renderer/webgraphicscontext3d_provider_impl.h"
 #include "content/renderer/webpublicsuffixlist_impl.h"
 #include "gpu/config/gpu_info.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_hardware_config.h"
@@ skipping 238 matching lines @@
   if (!file_utilities_) {
     file_utilities_.reset(new FileUtilities(thread_safe_sender_.get()));
     file_utilities_->set_sandbox_enabled(sandboxEnabled());
   }
   return file_utilities_.get();
 }
 
 blink::WebSandboxSupport* RendererBlinkPlatformImpl::sandboxSupport() {
 #if defined(OS_ANDROID) || defined(OS_WIN)
   // These platforms do not require sandbox support.
-  return NULL;
+  return nullptr;
 #else
   return sandbox_support_.get();
 #endif
 }
 
 blink::WebCookieJar* RendererBlinkPlatformImpl::cookieJar() {
   NOTREACHED() << "Use WebFrameClient::cookieJar() instead!";
-  return NULL;
+  return nullptr;
 }
 
 blink::WebThemeEngine* RendererBlinkPlatformImpl::themeEngine() {
   blink::WebThemeEngine* theme_engine =
       GetContentClient()->renderer()->OverrideThemeEngine();
   if (theme_engine)
     return theme_engine;
   return BlinkPlatformImpl::themeEngine();
 }
 
@@ skipping 57 matching lines @@
                                             0);
     if (sudden_termination_disables_ != 0)
       return;
   } else {
     sudden_termination_disables_++;
     if (sudden_termination_disables_ != 1)
       return;
   }
 
   RenderThread* thread = RenderThread::Get();
-  if (thread)  // NULL in unittests.
+  if (thread)  // nullptr in unittests.
     thread->Send(new RenderProcessHostMsg_SuddenTerminationChanged(enabled));
 }
 
 WebStorageNamespace* RendererBlinkPlatformImpl::createLocalStorageNamespace() {
   return new WebStorageNamespaceImpl();
 }
 
 
 //------------------------------------------------------------------------------
 
@@ skipping 140 matching lines @@
 #if defined(OS_MACOSX)
 
 bool RendererBlinkPlatformImpl::SandboxSupport::loadFont(NSFont* src_font,
                                                          CGFontRef* out,
                                                          uint32* font_id) {
   uint32 font_data_size;
   FontDescriptor src_font_descriptor(src_font);
   base::SharedMemoryHandle font_data;
   if (!RenderThread::Get()->Send(new RenderProcessHostMsg_LoadFont(
         src_font_descriptor, &font_data_size, &font_data, font_id))) {
-    *out = NULL;
+    *out = nullptr;
     *font_id = 0;
     return false;
   }
 
   if (font_data_size == 0 || font_data == base::SharedMemory::NULLHandle() ||
       *font_id == 0) {
     LOG(ERROR) << "Bad response from RenderProcessHostMsg_LoadFont() for " <<
         src_font_descriptor.font_name;
-    *out = NULL;
+    *out = nullptr;

[jochen (gone - plz use gerrit), 2015/10/20 12:27:35]

please don't change code unrelated to your CL

[hbos_chromium, 2015/10/20 15:42:23]

Acknowledged. Changed back to old NULL usage.

     *font_id = 0;
     return false;
   }
 
   // TODO(jeremy): Need to call back into WebKit to make sure that the font
   // isn't already activated, based on the font id.  If it's already
   // activated, don't reactivate it here - crbug.com/72727 .
 
   return FontLoader::CGFontRefFromBuffer(font_data, font_data_size, out);
 }
@@ skipping 75 matching lines @@
   GpuChannelHost* host = thread->EstablishGpuChannelSync(
       CAUSE_FOR_GPU_LAUNCH_CANVAS_2D);
   if (!host)
     return false;
 
   return host->gpu_info().SupportsAccelerated2dCanvas();
 }
 
 bool RendererBlinkPlatformImpl::isThreadedCompositingEnabled() {
   RenderThreadImpl* thread = RenderThreadImpl::current();
-  // thread can be NULL in tests.
+  // thread can be nullptr in tests.
   return thread && thread->compositor_task_runner().get();
 }
 
 bool RendererBlinkPlatformImpl::isThreadedAnimationEnabled() {
   RenderThreadImpl* thread = RenderThreadImpl::current();
   return thread ? thread->IsThreadedAnimationEnabled() : true;
 }
 
 double RendererBlinkPlatformImpl::audioHardwareSampleRate() {
   RenderThreadImpl* thread = RenderThreadImpl::current();
@@ skipping 184 matching lines @@
 
 //------------------------------------------------------------------------------
 
 blink::WebScrollbarBehavior* RendererBlinkPlatformImpl::scrollbarBehavior() {
   return web_scrollbar_behavior_.get();
 }
 
 //------------------------------------------------------------------------------
 
 WebBlobRegistry* RendererBlinkPlatformImpl::blobRegistry() {
-  // blob_registry_ can be NULL when running some tests.
+  // blob_registry_ can be nullptr when running some tests.
   return blob_registry_.get();
 }
 
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::sampleGamepads(WebGamepads& gamepads) {
   PlatformEventObserverBase* observer =
       platform_event_observers_.Lookup(blink::WebPlatformEventGamepad);
   if (!observer)
     return;
@@ skipping 12 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 WebRTCPeerConnectionHandler*
 RendererBlinkPlatformImpl::createRTCPeerConnectionHandler(
     WebRTCPeerConnectionHandlerClient* client) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   DCHECK(render_thread);
   if (!render_thread)
-    return NULL;
+    return nullptr;
 
 #if defined(ENABLE_WEBRTC)
   WebRTCPeerConnectionHandler* peer_connection_handler =
       GetContentClient()->renderer()->OverrideCreateWebRTCPeerConnectionHandler(
           client);
   if (peer_connection_handler)
     return peer_connection_handler;
 
   PeerConnectionDependencyFactory* rtc_dependency_factory =
       render_thread->GetPeerConnectionDependencyFactory();
   return rtc_dependency_factory->CreateRTCPeerConnectionHandler(client);
 #else
-  return NULL;
+  return nullptr;
 #endif  // defined(ENABLE_WEBRTC)
 }
 
+//------------------------------------------------------------------------------
+
+blink::WebRTCCertificateGenerator*
+RendererBlinkPlatformImpl::createRTCCertificateGenerator() {
+#if defined(ENABLE_WEBRTC)
+  return new RTCCertificateGenerator();
+#else
+  return nullptr;
+#endif  // defined(ENABLE_WEBRTC)
+}
+
 //------------------------------------------------------------------------------
 
 WebMediaStreamCenter* RendererBlinkPlatformImpl::createMediaStreamCenter(
     WebMediaStreamCenterClient* client) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   DCHECK(render_thread);
   if (!render_thread)
-    return NULL;
+    return nullptr;
   return render_thread->CreateMediaStreamCenter(client);
 }
 
 // static
 bool RendererBlinkPlatformImpl::SetSandboxEnabledForTesting(bool enable) {
   bool was_enabled = g_sandbox_enabled;
   g_sandbox_enabled = enable;
   return was_enabled;
 }
 
@@ skipping 13 matching lines @@
       new RenderProcessHostMsg_GetProcessMemorySizes(
           private_bytes, shared_bytes));
   return true;
 }
 
 //------------------------------------------------------------------------------
 
 blink::WebGraphicsContext3D*
 RendererBlinkPlatformImpl::createOffscreenGraphicsContext3D(
     const blink::WebGraphicsContext3D::Attributes& attributes) {
-  return createOffscreenGraphicsContext3D(attributes, NULL);
+  return createOffscreenGraphicsContext3D(attributes, nullptr);
 }
 
 blink::WebGraphicsContext3D*
 RendererBlinkPlatformImpl::createOffscreenGraphicsContext3D(
     const blink::WebGraphicsContext3D::Attributes& attributes,
     blink::WebGraphicsContext3D* share_context) {
-  return createOffscreenGraphicsContext3D(attributes, share_context, NULL);
+  return createOffscreenGraphicsContext3D(attributes, share_context, nullptr);
 }
 
 blink::WebGraphicsContext3D*
 RendererBlinkPlatformImpl::createOffscreenGraphicsContext3D(
     const blink::WebGraphicsContext3D::Attributes& attributes,
     blink::WebGraphicsContext3D* share_context,
     blink::WebGLInfo* gl_info) {
   if (!RenderThreadImpl::current())
-    return NULL;
+    return nullptr;
 
   scoped_refptr<GpuChannelHost> gpu_channel_host(
       RenderThreadImpl::current()->EstablishGpuChannelSync(
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE));
 
   if (gpu_channel_host.get() && gl_info) {
     const gpu::GPUInfo& gpu_info = gpu_channel_host->gpu_info();
     switch (gpu_info.context_info_state) {
       case gpu::kCollectInfoSuccess:
       case gpu::kCollectInfoNonFatalFailure:
@@ skipping 24 matching lines @@
           gpu_channel_host.get(),
           attributes,
           lose_context_when_out_of_memory,
           GURL(attributes.topDocumentURL),
           limits,
           static_cast<WebGraphicsContext3DCommandBufferImpl*>(share_context)));
 
   // Most likely the GPU process exited and the attempt to reconnect to it
   // failed. Need to try to restore the context again later.
   if (!context || !context->InitializeOnCurrentThread())
-      return NULL;
+      return nullptr;
   return context.release();
 }
 
 //------------------------------------------------------------------------------
 
 blink::WebGraphicsContext3DProvider*
 RendererBlinkPlatformImpl::createSharedOffscreenGraphicsContext3DProvider() {
   scoped_refptr<cc_blink::ContextProviderWebContext> provider =
       RenderThreadImpl::current()->SharedMainThreadContextProvider();
   if (!provider.get())
-    return NULL;
+    return nullptr;
   return new WebGraphicsContext3DProviderImpl(provider);
 }
 
 //------------------------------------------------------------------------------
 
 blink::WebCompositorSupport* RendererBlinkPlatformImpl::compositorSupport() {
   return &compositor_support_;
 }
 
 //------------------------------------------------------------------------------
@@ skipping 66 matching lines @@
 // static
 PlatformEventObserverBase*
 RendererBlinkPlatformImpl::CreatePlatformEventObserverFromType(
     blink::WebPlatformEventType type) {
   RenderThread* thread = RenderThreadImpl::current();
 
   // When running layout tests, those observers should not listen to the actual
   // hardware changes. In order to make that happen, they will receive a null
   // thread.
   if (thread && RenderThreadImpl::current()->layout_test_mode())
-    thread = NULL;
+    thread = nullptr;
 
   switch (type) {
     case blink::WebPlatformEventDeviceMotion:
       return new DeviceMotionEventPump(thread);
     case blink::WebPlatformEventDeviceOrientation:
       return new DeviceOrientationEventPump(thread);
     case blink::WebPlatformEventDeviceLight:
       return new DeviceLightEventPump(thread);
     case blink::WebPlatformEventGamepad:
       return new GamepadSharedMemoryReader(thread);
     case blink::WebPlatformEventScreenOrientation:
       return new ScreenOrientationObserver();
     default:
       // A default statement is required to prevent compilation errors when
       // Blink adds a new type.
       DVLOG(1) << "RendererBlinkPlatformImpl::startListening() with "
                   "unknown type.";
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void RendererBlinkPlatformImpl::SetPlatformEventObserverForTesting(
     blink::WebPlatformEventType type,
     scoped_ptr<PlatformEventObserverBase> observer) {
   DCHECK(type != blink::WebPlatformEventBattery);
 
   if (platform_event_observers_.Lookup(type))
     platform_event_observers_.Remove(type);
   platform_event_observers_.AddWithID(observer.release(), type);
@@ skipping 102 matching lines @@
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::MockBatteryStatusChangedForTesting(
     const blink::WebBatteryStatus& status) {
   if (!g_test_battery_status_listener)
     return;
   g_test_battery_status_listener->updateBatteryStatus(status);
 }
 
 }  // namespace content