Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/cast_channel/logger_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/test/simple_test_clock.h"
@@ skipping 11 matching lines @@
 using proto::AggregatedSocketEvent;
 using proto::EventType;
 using proto::Log;
 using proto::SocketEvent;
 
 class CastChannelLoggerTest : public testing::Test {
  public:
   // |logger_| will take ownership of |clock_|.
   CastChannelLoggerTest()
       : clock_(new base::SimpleTestClock),
-        logger_(new Logger(scoped_ptr<base::Clock>(clock_), base::Time())) {}
+        logger_(
+            new Logger(std::unique_ptr<base::Clock>(clock_), base::Time())) {}
   ~CastChannelLoggerTest() override {}
 
   bool Uncompress(const char* input, int length, std::string* output) {
     z_stream stream = {0};
 
     stream.next_in = reinterpret_cast<uint8_t*>(const_cast<char*>(input));
     stream.avail_in = length;
     stream.next_out = reinterpret_cast<uint8_t*>(&(*output)[0]);
     stream.avail_out = output->size();
 
@@ skipping 14 matching lines @@
       DCHECK(result == Z_OK);
     }
 
     if (stream.avail_in == 0) {
       success = true;
       output->resize(output->size() - stream.avail_out);
     }
     return success;
   }
 
-  scoped_ptr<Log> GetLog() {
+  std::unique_ptr<Log> GetLog() {
     size_t length = 0;
-    scoped_ptr<char[]> output = logger_->GetLogs(&length);
+    std::unique_ptr<char[]> output = logger_->GetLogs(&length);
     if (!output.get())
-      return scoped_ptr<Log>();
+      return std::unique_ptr<Log>();
 
     // 20kb should be enough for test purposes.
     std::string uncompressed(20000, 0);
     if (!Uncompress(output.get(), length, &uncompressed))
-      return scoped_ptr<Log>();
+      return std::unique_ptr<Log>();
 
-    scoped_ptr<Log> log(new Log);
+    std::unique_ptr<Log> log(new Log);
     if (!log->ParseFromString(uncompressed))
-      return scoped_ptr<Log>();
+      return std::unique_ptr<Log>();
 
     return log;
   }
 
  protected:
   base::SimpleTestClock* clock_;
   scoped_refptr<Logger> logger_;
 };
 
 TEST_F(CastChannelLoggerTest, BasicLogging) {
@@ skipping 19 matching lines @@
   auth_result =
       AuthResult("Parsing failed", AuthResult::ERROR_CERT_PARSING_FAILED);
   logger_->LogSocketChallengeReplyEvent(2, auth_result);
 
   LastErrors last_errors = logger_->GetLastErrors(2);
   EXPECT_EQ(last_errors.event_type, proto::AUTH_CHALLENGE_REPLY);
   EXPECT_EQ(last_errors.net_return_value, net::OK);
   EXPECT_EQ(last_errors.challenge_reply_error_type,
             proto::CHALLENGE_REPLY_ERROR_CERT_PARSING_FAILED);
 
-  scoped_ptr<Log> log = GetLog();
+  std::unique_ptr<Log> log = GetLog();
   ASSERT_TRUE(log);
 
   ASSERT_EQ(2, log->aggregated_socket_event_size());
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log->aggregated_socket_event(0);
     EXPECT_EQ(1, aggregated_socket_event.id());
     EXPECT_EQ(3, aggregated_socket_event.socket_event_size());
     {
       const SocketEvent& event = aggregated_socket_event.socket_event(0);
@@ skipping 109 matching lines @@
   logger_->LogSocketEventWithRv(1, EventType::SOCKET_WRITE, 20);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
   logger_->LogSocketEventWithRv(2, EventType::SOCKET_READ, 100);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEventWithRv(2, EventType::SOCKET_WRITE, 100);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEventWithRv(2, EventType::SOCKET_WRITE, -5);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
-  scoped_ptr<Log> log = GetLog();
+  std::unique_ptr<Log> log = GetLog();
   ASSERT_TRUE(log);
 
   ASSERT_EQ(2, log->aggregated_socket_event_size());
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log->aggregated_socket_event(0);
     EXPECT_EQ(1, aggregated_socket_event.id());
     EXPECT_EQ(4, aggregated_socket_event.socket_event_size());
     EXPECT_EQ(80, aggregated_socket_event.bytes_read());
     EXPECT_EQ(20, aggregated_socket_event.bytes_written());
   }
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log->aggregated_socket_event(1);
     EXPECT_EQ(2, aggregated_socket_event.id());
     EXPECT_EQ(3, aggregated_socket_event.socket_event_size());
     EXPECT_EQ(100, aggregated_socket_event.bytes_read());
     EXPECT_EQ(100, aggregated_socket_event.bytes_written());
   }
 }
 
 TEST_F(CastChannelLoggerTest, TooManySockets) {
   for (int i = 0; i < kMaxSocketsToLog + 5; i++) {
     logger_->LogSocketEvent(i, EventType::CAST_SOCKET_CREATED);
   }
 
-  scoped_ptr<Log> log = GetLog();
+  std::unique_ptr<Log> log = GetLog();
   ASSERT_TRUE(log);
 
   ASSERT_EQ(kMaxSocketsToLog, log->aggregated_socket_event_size());
   EXPECT_EQ(5, log->num_evicted_aggregated_socket_events());
   EXPECT_EQ(5, log->num_evicted_socket_events());
 
   const AggregatedSocketEvent& aggregated_socket_event =
       log->aggregated_socket_event(0);
   EXPECT_EQ(5, aggregated_socket_event.id());
 }
 
 TEST_F(CastChannelLoggerTest, TooManyEvents) {
   for (int i = 0; i < kMaxEventsPerSocket + 5; i++) {
     logger_->LogSocketEvent(1, EventType::CAST_SOCKET_CREATED);
     clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   }
 
-  scoped_ptr<Log> log = GetLog();
+  std::unique_ptr<Log> log = GetLog();
   ASSERT_TRUE(log);
 
   ASSERT_EQ(1, log->aggregated_socket_event_size());
   EXPECT_EQ(0, log->num_evicted_aggregated_socket_events());
   EXPECT_EQ(5, log->num_evicted_socket_events());
 
   const AggregatedSocketEvent& aggregated_socket_event =
       log->aggregated_socket_event(0);
   ASSERT_EQ(kMaxEventsPerSocket, aggregated_socket_event.socket_event_size());
   EXPECT_EQ(5, aggregated_socket_event.socket_event(0).timestamp_micros());
 }
 
 TEST_F(CastChannelLoggerTest, Reset) {
   logger_->LogSocketEvent(1, EventType::CAST_SOCKET_CREATED);
 
-  scoped_ptr<Log> log = GetLog();
+  std::unique_ptr<Log> log = GetLog();
   ASSERT_TRUE(log);
 
   EXPECT_EQ(1, log->aggregated_socket_event_size());
 
   logger_->Reset();
 
   log = GetLog();
   ASSERT_TRUE(log);
 
   EXPECT_EQ(0, log->aggregated_socket_event_size());
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions