Convert //components/mus from scoped_ptr to std::unique_ptr

components/mus/common/event_param_traits.cc

 // Copyright (c) 2016 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 "components/mus/common/event_param_traits.h"
 
 #include <string.h>
 
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_param_traits.h"
@@ skipping 96 matching lines @@
       default:                                                          \
         defaultCase;                                                    \
     }                                                                   \
   }
 
 // Concrete event type (T) implementation procedures: size, write, read, log.
 #define SIZE_EVENT(T) ParamTraits<T>::GetSize(s, *static_cast<T*>(p.get()));
 #define WRITE_EVENT(T)                     \
   ParamTraits<T>::Write(m, *static_cast<T*>(p.get())); \
   break;
-#define READ_EVENT(T)                                    \
-  {                                                      \
-    scoped_ptr<T> event(new T(type, time_stamp, flags)); \
-    if (!ParamTraits<T>::Read(m, iter, event.get())) {   \
-      p->reset();                                        \
-      return false;                                      \
-    } else {                                             \
-      *p = std::move(event);                             \
-      return true;                                       \
-    }                                                    \
+#define READ_EVENT(T)                                         \
+  {                                                           \
+    std::unique_ptr<T> event(new T(type, time_stamp, flags)); \
+    if (!ParamTraits<T>::Read(m, iter, event.get())) {        \
+      p->reset();                                             \
+      return false;                                           \
+    } else {                                                  \
+      *p = std::move(event);                                  \
+      return true;                                            \
+    }                                                         \
   }
 #define LOG_EVENT(T) return ParamTraits<T>::Log(*static_cast<T*>(p.get()), l);
 
 // void SizeEvent(ui::EventType type, int flags, base::PickleSizer* s,
 //                const ui::ScopedEvent& p) { ... }
 EVENT_IMPL(void,
            SizeEvent,
            SIZE_EVENT,
            /* default switch/case: no-op */,
            base::PickleSizer* s,
@@ skipping 138 matching lines @@
   memcpy(p, data, sizeof(param_type));
   return true;
 }
 
 void ParamTraits<ui::GestureEventDetails::Details>::Log(const param_type& p,
                                                         std::string* l) {
   l->append("<ui::GestureEventDetails::Details>");
 }
 
 }  // namespace IPC