Remove calls to ScopedToUnique and UniqueToScoped

webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 189 matching lines @@
   for (size_t i = 0; i < packets.size(); ++i) {
     std::unique_ptr<rtcp::TransportFeedback> feedback(
         new rtcp::TransportFeedback());
     feedback->WithBase(packets[i].sequence_number,
                        packets[i].arrival_time_ms * 1000);
 
     EXPECT_TRUE(feedback->WithReceivedPacket(
         packets[i].sequence_number, packets[i].arrival_time_ms * 1000));
 
     rtc::Buffer raw_packet = feedback->Build();
-    feedback = rtc::ScopedToUnique(rtcp::TransportFeedback::ParseFrom(
-        raw_packet.data(), raw_packet.size()));
+    feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
+                                                  raw_packet.size());
 
     std::vector<PacketInfo> expected_packets;
     expected_packets.push_back(packets[i]);
 
     EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
         .Times(1)
         .WillOnce(Invoke([expected_packets, this](
             const std::vector<PacketInfo>& feedback_vector) {
           ComparePacketVectors(expected_packets, feedback_vector);
         }));
@@ skipping 47 matching lines @@
                      sent_packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : sent_packets) {
     EXPECT_TRUE(feedback->WithReceivedPacket(packet.sequence_number,
                                              packet.arrival_time_ms * 1000));
   }
   EXPECT_FALSE(feedback->WithReceivedPacket(info.sequence_number,
                                             info.arrival_time_ms * 1000));
 
   rtc::Buffer raw_packet = feedback->Build();
-  feedback = rtc::ScopedToUnique(
-      rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()));
+  feedback =
+      rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
 
   std::vector<PacketInfo> received_feedback;
 
   EXPECT_TRUE(feedback.get() != nullptr);
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
       .WillOnce(Invoke([sent_packets, &received_feedback](
           const std::vector<PacketInfo>& feedback_vector) {
         EXPECT_EQ(sent_packets.size(), feedback_vector.size());
         received_feedback = feedback_vector;
       }));
   adapter_->OnTransportFeedback(*feedback.get());
 
   // Create a new feedback message and add the trailing item.
   feedback.reset(new rtcp::TransportFeedback());
   feedback->WithBase(info.sequence_number, info.arrival_time_ms * 1000);
   EXPECT_TRUE(feedback->WithReceivedPacket(info.sequence_number,
                                            info.arrival_time_ms * 1000));
   raw_packet = feedback->Build();
-  feedback = rtc::ScopedToUnique(
-      rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()));
+  feedback =
+      rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
 
   EXPECT_TRUE(feedback.get() != nullptr);
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
       .WillOnce(Invoke(
           [&received_feedback](const std::vector<PacketInfo>& feedback_vector) {
             EXPECT_EQ(1u, feedback_vector.size());
             received_feedback.push_back(feedback_vector[0]);
           }));
   adapter_->OnTransportFeedback(*feedback.get());
 
   sent_packets.push_back(info);
 
   ComparePacketVectors(sent_packets, received_feedback);
 }
 
 }  // namespace test
 }  // namespace webrtc