EDK: More scoped_ptr -> std::unique_ptr conversions.

mojo/edk/system/message_in_transit.h

 // Copyright 2013 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.
 
 #ifndef MOJO_EDK_SYSTEM_MESSAGE_IN_TRANSIT_H_
 #define MOJO_EDK_SYSTEM_MESSAGE_IN_TRANSIT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <ostream>
 #include <vector>
 
 #include "base/memory/aligned_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "mojo/edk/system/channel_endpoint_id.h"
 #include "mojo/edk/system/dispatcher.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace system {
 
 class Channel;
@@ skipping 155 matching lines @@
   // TODO(vtl): In |RawChannelPosix|, the alignment requirements are currently
   // satisified on a faith-based basis.
   static bool GetNextMessageSize(const void* buffer,
                                  size_t buffer_size,
                                  size_t* next_message_size);
 
   // Makes this message "own" the given set of dispatchers. The dispatchers must
   // not be referenced from anywhere else (in particular, not from the handle
   // table), i.e., each dispatcher must have a reference count of 1. This
   // message must not already have dispatchers.
-  void SetDispatchers(scoped_ptr<DispatcherVector> dispatchers);
+  void SetDispatchers(std::unique_ptr<DispatcherVector> dispatchers);
 
   // Sets the |TransportData| for this message. This should only be done when
   // there are no dispatchers and no existing |TransportData|.
-  void SetTransportData(scoped_ptr<TransportData> transport_data);
+  void SetTransportData(std::unique_ptr<TransportData> transport_data);
 
   // Serializes any dispatchers to the secondary buffer. This message must not
   // already have a secondary buffer (so this must only be called once). The
   // caller must ensure (e.g., by holding on to a reference) that |channel|
   // stays alive through the call.
   void SerializeAndCloseDispatchers(Channel* channel);
 
   // Gets the main buffer and its size (in number of bytes), respectively.
   const void* main_buffer() const { return main_buffer_.get(); }
   size_t main_buffer_size() const { return main_buffer_size_; }
@@ skipping 63 matching lines @@
 
   const Header* header() const {
     return reinterpret_cast<const Header*>(main_buffer_.get());
   }
   Header* header() { return reinterpret_cast<Header*>(main_buffer_.get()); }
 
   void ConstructorHelper(Type type, Subtype subtype, uint32_t num_bytes);
   void UpdateTotalSize();
 
   const size_t main_buffer_size_;
-  const scoped_ptr<char, base::AlignedFreeDeleter> main_buffer_;  // Never null.
+  // Never null.
+  const std::unique_ptr<char, base::AlignedFreeDeleter> main_buffer_;
 
-  scoped_ptr<TransportData> transport_data_;  // May be null.
+  std::unique_ptr<TransportData> transport_data_;  // May be null.
 
   // Any dispatchers that may be attached to this message. These dispatchers
   // should be "owned" by this message, i.e., have a ref count of exactly 1. (We
   // allow a dispatcher entry to be null, in case it couldn't be duplicated for
   // some reason.)
-  scoped_ptr<DispatcherVector> dispatchers_;
+  std::unique_ptr<DispatcherVector> dispatchers_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(MessageInTransit);
 };
 
 // So logging macros and |DCHECK_EQ()|, etc. work.
 MOJO_SYSTEM_IMPL_EXPORT inline std::ostream& operator<<(
     std::ostream& out,
     MessageInTransit::Type type) {
   return out << static_cast<uint16_t>(type);
 }
 
 // So logging macros and |DCHECK_EQ()|, etc. work.
 MOJO_SYSTEM_IMPL_EXPORT inline std::ostream& operator<<(
     std::ostream& out,
     MessageInTransit::Subtype subtype) {
   return out << static_cast<uint16_t>(subtype);
 }
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_MESSAGE_IN_TRANSIT_H_