Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

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"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
@@ skipping 1130 matching lines @@
 
 // static
 void RendererBlinkPlatformImpl::SetMockDeviceOrientationDataForTesting(
     const blink::WebDeviceOrientationData& data) {
   g_test_device_orientation_data.Get() = data;
 }
 
 //------------------------------------------------------------------------------
 
 // static
-PlatformEventObserverBase*
+std::unique_ptr<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;
 
   switch (type) {
     case blink::WebPlatformEventTypeDeviceMotion:
-      return new DeviceMotionEventPump(thread);
+      return base::MakeUnique<DeviceMotionEventPump>(thread);
     case blink::WebPlatformEventTypeDeviceOrientation:
-      return new DeviceOrientationEventPump(thread);
+      return base::MakeUnique<DeviceOrientationEventPump>(thread);
     case blink::WebPlatformEventTypeDeviceOrientationAbsolute:
-      return new DeviceOrientationAbsoluteEventPump(thread);
+      return base::MakeUnique<DeviceOrientationAbsoluteEventPump>(thread);
     case blink::WebPlatformEventTypeDeviceLight:
-      return new DeviceLightEventPump(thread);
+      return base::MakeUnique<DeviceLightEventPump>(thread);
     case blink::WebPlatformEventTypeGamepad:
-      return new GamepadSharedMemoryReader(thread);
+      return base::MakeUnique<GamepadSharedMemoryReader>(thread);
     case blink::WebPlatformEventTypeScreenOrientation:
-      return new ScreenOrientationObserver();
+      return base::MakeUnique<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;
 }
 
 void RendererBlinkPlatformImpl::SetPlatformEventObserverForTesting(
     blink::WebPlatformEventType type,
     std::unique_ptr<PlatformEventObserverBase> observer) {
   if (platform_event_observers_.Lookup(type))
     platform_event_observers_.Remove(type);
-  platform_event_observers_.AddWithID(observer.release(), type);
+  platform_event_observers_.AddWithID(std::move(observer), type);
 }
 
 blink::InterfaceProvider* RendererBlinkPlatformImpl::interfaceProvider() {
   return blink_interface_provider_.get();
 }
 
 void RendererBlinkPlatformImpl::startListening(
     blink::WebPlatformEventType type,
     blink::WebPlatformEventListener* listener) {
   PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
   if (!observer) {
-    observer = CreatePlatformEventObserverFromType(type);
-    if (!observer)
+    std::unique_ptr<PlatformEventObserverBase> new_observer =
+        CreatePlatformEventObserverFromType(type);
+    if (!new_observer)
       return;
-    platform_event_observers_.AddWithID(observer, static_cast<int32_t>(type));
+    observer = new_observer.get();
+    platform_event_observers_.AddWithID(std::move(new_observer),
+                                        static_cast<int32_t>(type));
   }
   observer->Start(listener);
 
   // Device events (motion, orientation and light) expect to get an event fired
   // as soon as a listener is registered if a fake data was passed before.
   // TODO(mlamouri,timvolodine): make those send mock values directly instead of
   // using this broken pattern.
   if (RenderThreadImpl::current() &&
       RenderThreadImpl::current()->layout_test_mode() &&
       (type == blink::WebPlatformEventTypeDeviceMotion ||
@@ skipping 69 matching lines @@
   return &trial_token_validator_;
 }
 
 void RendererBlinkPlatformImpl::workerContextCreated(
     const v8::Local<v8::Context>& worker) {
   GetContentClient()->renderer()->DidInitializeWorkerContextOnWorkerThread(
       worker);
 }
 
 }  // namespace content