[blink] Unique pointers in Platform.h

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 <memory>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 72 matching lines @@
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.h"
 #include "storage/common/database/database_identifier.h"
 #include "storage/common/quota/quota_types.h"
 #include "third_party/WebKit/public/platform/BlameContext.h"
 #include "third_party/WebKit/public/platform/FilePathConversion.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebAudioLatencyHint.h"
 #include "third_party/WebKit/public/platform/WebBlobRegistry.h"
 #include "third_party/WebKit/public/platform/WebFileInfo.h"
+#include "third_party/WebKit/public/platform/WebMediaRecorderHandler.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamCenter.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamCenterClient.h"
 #include "third_party/WebKit/public/platform/WebPluginListBuilder.h"
+#include "third_party/WebKit/public/platform/WebRTCCertificateGenerator.h"
+#include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandler.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDeviceMotionListener.h"
 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDeviceOrientationListener.h"
+#include "third_party/WebKit/public/platform/modules/webmidi/WebMIDIAccessor.h"
 #include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "url/gurl.h"
 
 #if defined(OS_MACOSX)
 #include "content/common/mac/font_descriptor.h"
 #include "content/common/mac/font_loader.h"
 #include "content/renderer/webscrollbarbehavior_impl_mac.h"
 #include "third_party/WebKit/public/platform/mac/WebSandboxSupport.h"
 #endif
@@ skipping 31 matching lines @@
 using blink::Platform;
 using blink::WebAudioDevice;
 using blink::WebAudioLatencyHint;
 using blink::WebBlobRegistry;
 using blink::WebCanvasCaptureHandler;
 using blink::WebDatabaseObserver;
 using blink::WebFileInfo;
 using blink::WebFileSystem;
 using blink::WebIDBFactory;
 using blink::WebImageCaptureFrameGrabber;
-using blink::WebMIDIAccessor;
 using blink::WebMediaPlayer;
 using blink::WebMediaRecorderHandler;
 using blink::WebMediaStream;
 using blink::WebMediaStreamCenter;
 using blink::WebMediaStreamCenterClient;
 using blink::WebMediaStreamTrack;
 using blink::WebRTCPeerConnectionHandler;
 using blink::WebRTCPeerConnectionHandlerClient;
 using blink::WebStorageNamespace;
 using blink::WebSize;
@@ skipping 305 matching lines @@
     sudden_termination_disables_++;
     if (sudden_termination_disables_ != 1)
       return;
   }
 
   RenderThread* thread = RenderThread::Get();
   if (thread)  // NULL in unittests.
     thread->Send(new RenderProcessHostMsg_SuddenTerminationChanged(enabled));
 }
 
-WebStorageNamespace* RendererBlinkPlatformImpl::CreateLocalStorageNamespace() {
+std::unique_ptr<WebStorageNamespace>
+RendererBlinkPlatformImpl::CreateLocalStorageNamespace() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoLocalStorage)) {
     if (!local_storage_cached_areas_) {
       local_storage_cached_areas_.reset(new LocalStorageCachedAreas(
           RenderThreadImpl::current()->GetStoragePartitionService()));
     }
-    return new LocalStorageNamespace(local_storage_cached_areas_.get());
+    return base::MakeUnique<LocalStorageNamespace>(
+        local_storage_cached_areas_.get());
   }
 
-  return new WebStorageNamespaceImpl();
+  return base::MakeUnique<WebStorageNamespaceImpl>();
 }
 
 
 //------------------------------------------------------------------------------
 
 WebIDBFactory* RendererBlinkPlatformImpl::IdbFactory() {
   return web_idb_factory_.get();
 }
 
 //------------------------------------------------------------------------------
 
-blink::WebServiceWorkerCacheStorage* RendererBlinkPlatformImpl::CacheStorage(
+std::unique_ptr<blink::WebServiceWorkerCacheStorage>
+RendererBlinkPlatformImpl::CreateCacheStorage(
     const blink::WebSecurityOrigin& security_origin) {
-  return new WebServiceWorkerCacheStorageImpl(thread_safe_sender_.get(),
-                                              security_origin);
+  return base::MakeUnique<WebServiceWorkerCacheStorageImpl>(
+      thread_safe_sender_.get(), security_origin);
 }
 
 //------------------------------------------------------------------------------
 
 WebFileSystem* RendererBlinkPlatformImpl::FileSystem() {
   return WebFileSystemImpl::ThreadSpecificInstance(default_task_runner_);
 }
 
 WebString RendererBlinkPlatformImpl::FileSystemCreateOriginIdentifier(
     const blink::WebSecurityOrigin& origin) {
@@ skipping 171 matching lines @@
 }
 
 unsigned RendererBlinkPlatformImpl::AudioHardwareOutputChannels() {
   return GetAudioHardwareParams().channels();
 }
 
 WebDatabaseObserver* RendererBlinkPlatformImpl::DatabaseObserver() {
   return web_database_observer_impl_.get();
 }
 
-WebAudioDevice* RendererBlinkPlatformImpl::CreateAudioDevice(
+std::unique_ptr<WebAudioDevice> RendererBlinkPlatformImpl::CreateAudioDevice(
     unsigned input_channels,
     unsigned channels,
     const blink::WebAudioLatencyHint& latency_hint,
     WebAudioDevice::RenderCallback* callback,
     const blink::WebString& input_device_id,
     const blink::WebSecurityOrigin& security_origin) {
   // Use a mock for testing.
-  blink::WebAudioDevice* mock_device =
+  std::unique_ptr<blink::WebAudioDevice> mock_device =
       GetContentClient()->renderer()->OverrideCreateAudioDevice(latency_hint);
   if (mock_device)
     return mock_device;
 
   // The |channels| does not exactly identify the channel layout of the
   // device. The switch statement below assigns a best guess to the channel
   // layout based on number of channels.
   media::ChannelLayout layout = media::GuessChannelLayout(channels);
   if (layout == media::CHANNEL_LAYOUT_UNSUPPORTED)
     layout = media::CHANNEL_LAYOUT_DISCRETE;
@@ skipping 12 matching lines @@
 bool RendererBlinkPlatformImpl::LoadAudioResource(
     blink::WebAudioBus* destination_bus,
     const char* audio_file_data,
     size_t data_size) {
   return DecodeAudioFileData(
       destination_bus, audio_file_data, data_size);
 }
 
 //------------------------------------------------------------------------------
 
-blink::WebMIDIAccessor* RendererBlinkPlatformImpl::CreateMIDIAccessor(
+std::unique_ptr<blink::WebMIDIAccessor>
+RendererBlinkPlatformImpl::CreateMIDIAccessor(
     blink::WebMIDIAccessorClient* client) {
-  blink::WebMIDIAccessor* accessor =
+  std::unique_ptr<blink::WebMIDIAccessor> accessor =
       GetContentClient()->renderer()->OverrideCreateMIDIAccessor(client);
   if (accessor)
     return accessor;
 
-  return new RendererWebMIDIAccessorImpl(client);
+  return base::MakeUnique<RendererWebMIDIAccessorImpl>(client);
 }
 
 void RendererBlinkPlatformImpl::GetPluginList(
     bool refresh,
     const blink::WebSecurityOrigin& mainFrameOrigin,
     blink::WebPluginListBuilder* builder) {
 #if BUILDFLAG(ENABLE_PLUGINS)
   std::vector<WebPluginInfo> plugins;
   if (!plugin_refresh_allowed_)
     refresh = false;
@@ skipping 42 matching lines @@
 void RendererBlinkPlatformImpl::SampleGamepads(device::Gamepads& gamepads) {
   PlatformEventObserverBase* observer =
       platform_event_observers_.Lookup(blink::kWebPlatformEventTypeGamepad);
   if (!observer)
     return;
   static_cast<RendererGamepadProvider*>(observer)->SampleGamepads(gamepads);
 }
 
 //------------------------------------------------------------------------------
 
-WebMediaRecorderHandler*
+std::unique_ptr<WebMediaRecorderHandler>
 RendererBlinkPlatformImpl::CreateMediaRecorderHandler() {
 #if BUILDFLAG(ENABLE_WEBRTC)
-  return new content::MediaRecorderHandler();
+  return base::MakeUnique<content::MediaRecorderHandler>();
 #else
   return nullptr;
 #endif
 }
 
 //------------------------------------------------------------------------------
 
-WebRTCPeerConnectionHandler*
+std::unique_ptr<WebRTCPeerConnectionHandler>
 RendererBlinkPlatformImpl::CreateRTCPeerConnectionHandler(
     WebRTCPeerConnectionHandlerClient* client) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   DCHECK(render_thread);
   if (!render_thread)
-    return NULL;
+    return nullptr;
 
 #if BUILDFLAG(ENABLE_WEBRTC)
-  WebRTCPeerConnectionHandler* peer_connection_handler =
+  std::unique_ptr<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  // BUILDFLAG(ENABLE_WEBRTC)
 }
 
 //------------------------------------------------------------------------------
 
-blink::WebRTCCertificateGenerator*
+std::unique_ptr<blink::WebRTCCertificateGenerator>
 RendererBlinkPlatformImpl::CreateRTCCertificateGenerator() {
 #if BUILDFLAG(ENABLE_WEBRTC)
-  return new RTCCertificateGenerator();
+  return base::MakeUnique<RTCCertificateGenerator>();
 #else
   return nullptr;
 #endif  // BUILDFLAG(ENABLE_WEBRTC)
 }
 
 //------------------------------------------------------------------------------
 
-WebMediaStreamCenter* RendererBlinkPlatformImpl::CreateMediaStreamCenter(
+std::unique_ptr<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;
 }
 
 //------------------------------------------------------------------------------
 
-WebCanvasCaptureHandler* RendererBlinkPlatformImpl::CreateCanvasCaptureHandler(
+std::unique_ptr<WebCanvasCaptureHandler>
+RendererBlinkPlatformImpl::CreateCanvasCaptureHandler(
     const WebSize& size,
     double frame_rate,
     WebMediaStreamTrack* track) {
 #if BUILDFLAG(ENABLE_WEBRTC)
   return CanvasCaptureHandler::CreateCanvasCaptureHandler(
       size, frame_rate, RenderThread::Get()->GetIOTaskRunner(), track);
 #else
   return nullptr;
 #endif  // BUILDFLAG(ENABLE_WEBRTC)
 }
@@ skipping 37 matching lines @@
   // Takes ownership of |media_stream_source|.
   web_media_stream_source.SetExtraData(media_stream_source);
 
   media_stream_source->ConnectToTrack(web_media_stream_track);
   web_media_stream->AddTrack(web_media_stream_track);
 #endif
 }
 
 //------------------------------------------------------------------------------
 
-WebImageCaptureFrameGrabber*
+std::unique_ptr<WebImageCaptureFrameGrabber>
 RendererBlinkPlatformImpl::CreateImageCaptureFrameGrabber() {
 #if BUILDFLAG(ENABLE_WEBRTC)
-  return new ImageCaptureFrameGrabber();
+  return base::MakeUnique<ImageCaptureFrameGrabber>();
 #else
   return nullptr;
 #endif  // BUILDFLAG(ENABLE_WEBRTC)
 }
 
 //------------------------------------------------------------------------------
 
-blink::WebSpeechSynthesizer* RendererBlinkPlatformImpl::CreateSpeechSynthesizer(
+std::unique_ptr<blink::WebSpeechSynthesizer>
+RendererBlinkPlatformImpl::CreateSpeechSynthesizer(
     blink::WebSpeechSynthesizerClient* client) {
   return GetContentClient()->renderer()->OverrideSpeechSynthesizer(client);
 }
 
 //------------------------------------------------------------------------------
 
 static void Collect3DContextInformation(
     blink::Platform::GraphicsInfo* gl_info,
     const gpu::GPUInfo& gpu_info) {
   DCHECK(gl_info);
@@ skipping 14 matching lines @@
       break;
     case gpu::kCollectInfoFatalFailure:
     case gpu::kCollectInfoNone:
       gl_info->error_message = WebString::FromUTF8(
           "Failed to collect gpu information, GLSurface or GLContext "
           "creation failed");
       break;
   }
 }
 
-blink::WebGraphicsContext3DProvider*
+std::unique_ptr<blink::WebGraphicsContext3DProvider>
 RendererBlinkPlatformImpl::CreateOffscreenGraphicsContext3DProvider(
     const blink::Platform::ContextAttributes& web_attributes,
     const blink::WebURL& top_document_web_url,
     blink::WebGraphicsContext3DProvider* share_provider,
     blink::Platform::GraphicsInfo* gl_info) {
   DCHECK(gl_info);
   if (!RenderThreadImpl::current()) {
     std::string error_message("Failed to run in Current RenderThreadImpl");
     gl_info->error_message = WebString::FromUTF8(error_message);
     return nullptr;
@@ skipping 57 matching lines @@
   constexpr bool automatic_flushes = true;
   constexpr bool support_locking = false;
 
   scoped_refptr<ui::ContextProviderCommandBuffer> provider(
       new ui::ContextProviderCommandBuffer(
           std::move(gpu_channel_host), gpu::GPU_STREAM_DEFAULT,
           gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle,
           GURL(top_document_web_url), automatic_flushes, support_locking,
           gpu::SharedMemoryLimits(), attributes, share_context,
           ui::command_buffer_metrics::OFFSCREEN_CONTEXT_FOR_WEBGL));
-  return new WebGraphicsContext3DProviderImpl(std::move(provider),
-                                              is_software_rendering);
+  return base::MakeUnique<WebGraphicsContext3DProviderImpl>(
+      std::move(provider), is_software_rendering);
 }
 
 //------------------------------------------------------------------------------
 
-blink::WebGraphicsContext3DProvider*
+std::unique_ptr<blink::WebGraphicsContext3DProvider>
 RendererBlinkPlatformImpl::CreateSharedOffscreenGraphicsContext3DProvider() {
   auto* thread = RenderThreadImpl::current();
 
   scoped_refptr<ui::ContextProviderCommandBuffer> provider =
       thread->SharedMainThreadContextProvider();
   if (!provider)
     return nullptr;
 
   scoped_refptr<gpu::GpuChannelHost> host = thread->EstablishGpuChannelSync();
   // This shouldn't normally fail because we just got |provider|. But the
   // channel can become lost on the IO thread since then. It is important that
   // this happens after getting |provider|. In the case that this GpuChannelHost
   // is not the same one backing |provider|, the context behind the |provider|
   // will be already lost/dead on arrival, so the value we get for
   // |is_software_rendering| will never be wrong.
   if (!host)
     return nullptr;
 
   bool is_software_rendering = host->gpu_info().software_rendering;
 
-  return new WebGraphicsContext3DProviderImpl(std::move(provider),
-                                              is_software_rendering);
+  return base::MakeUnique<WebGraphicsContext3DProviderImpl>(
+      std::move(provider), is_software_rendering);
 }
 
 //------------------------------------------------------------------------------
 
 gpu::GpuMemoryBufferManager*
 RendererBlinkPlatformImpl::GetGpuMemoryBufferManager() {
   RenderThreadImpl* thread = RenderThreadImpl::current();
   return thread ? thread->GetGpuMemoryBufferManager() : nullptr;
 }
 
@@ skipping 193 matching lines @@
 //------------------------------------------------------------------------------
 void RendererBlinkPlatformImpl::RequestPurgeMemory() {
   // TODO(tasak|bashi): We should use ChildMemoryCoordinator here, but
   // ChildMemoryCoordinator isn't always available as it's only initialized
   // when kMemoryCoordinatorV0 is enabled.
   // Use ChildMemoryCoordinator when memory coordinator is always enabled.
   base::MemoryCoordinatorClientRegistry::GetInstance()->PurgeMemory();
 }
 
 }  // namespace content