Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/presentation/presentation_service_impl_unittest.cc

 // Copyright 2015 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/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/location.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/public/browser/presentation_service_delegate.h"
 #include "content/public/browser/presentation_session.h"
 #include "content/public/common/presentation_constants.h"
 #include "content/test/test_render_frame_host.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
@@ skipping 94 matching lines @@
                     const PresentationSessionMessageCallback& message_cb));
   MOCK_METHOD5(SendMessageRawPtr,
                void(int render_process_id,
                     int render_frame_id,
                     const content::PresentationSessionInfo& session,
                     PresentationSessionMessage* message_request,
                     const SendMessageCallback& send_message_cb));
   void SendMessage(int render_process_id,
                    int render_frame_id,
                    const content::PresentationSessionInfo& session,
-                   scoped_ptr<PresentationSessionMessage> message_request,
+                   std::unique_ptr<PresentationSessionMessage> message_request,
                    const SendMessageCallback& send_message_cb) override {
     SendMessageRawPtr(render_process_id, render_frame_id, session,
                       message_request.release(), send_message_cb);
   }
   MOCK_METHOD4(ListenForConnectionStateChange,
                void(int render_process_id,
                     int render_frame_id,
                     const content::PresentationSessionInfo& connection,
                     const content::PresentationConnectionStateChangedCallback&
                         state_changed_cb));
@@ skipping 187 matching lines @@
     {
     base::RunLoop run_loop;
     EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _, _))
         .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                         SaveArg<3>(&message_cb)));
     service_ptr_->ListenForSessionMessages(session.Clone());
     run_loop.Run();
     }
 
     ScopedVector<PresentationSessionMessage> messages;
-    scoped_ptr<content::PresentationSessionMessage> message;
+    std::unique_ptr<content::PresentationSessionMessage> message;
     message.reset(
         new content::PresentationSessionMessage(PresentationMessageType::TEXT));
     message->message = text_msg;
     messages.push_back(std::move(message));
     message.reset(new content::PresentationSessionMessage(
         PresentationMessageType::ARRAY_BUFFER));
     message->data.reset(new std::vector<uint8_t>(binary_data));
     messages.push_back(std::move(message));
 
     std::vector<mojom::SessionMessagePtr> actual_msgs;
     {
       base::RunLoop run_loop;
       EXPECT_CALL(mock_client_, MessagesReceived())
           .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
       message_cb.Run(std::move(messages), pass_ownership);
       run_loop.Run();
     }
     ExpectSessionMessages(expected_msgs, mock_client_.messages_received_);
   }
 
   MockPresentationServiceDelegate mock_delegate_;
 
-  scoped_ptr<PresentationServiceImpl> service_impl_;
+  std::unique_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<mojom::PresentationService> service_ptr_;
 
   MockPresentationServiceClient mock_client_;
-  scoped_ptr<mojo::Binding<mojom::PresentationServiceClient>> client_binding_;
+  std::unique_ptr<mojo::Binding<mojom::PresentationServiceClient>>
+      client_binding_;
 
   base::Closure run_loop_quit_closure_;
   int default_session_started_count_;
 };
 
 TEST_F(PresentationServiceImplTest, ListenForScreenAvailability) {
   ListenForScreenAvailabilityAndWait(kPresentationUrl, true);
 
   SimulateScreenAvailabilityChangeAndWait(kPresentationUrl, true);
   SimulateScreenAvailabilityChangeAndWait(kPresentationUrl, false);
@@ skipping 304 matching lines @@
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   // Make sure |test_message| gets deleted.
-  scoped_ptr<PresentationSessionMessage> scoped_test_message(test_message);
+  std::unique_ptr<PresentationSessionMessage> scoped_test_message(test_message);
   EXPECT_TRUE(test_message);
   EXPECT_FALSE(test_message->is_binary());
   EXPECT_LE(test_message->message.size(), kMaxPresentationSessionMessageSize);
   EXPECT_EQ(message, test_message->message);
   ASSERT_FALSE(test_message->data);
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendArrayBuffer) {
@@ skipping 16 matching lines @@
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   // Make sure |test_message| gets deleted.
-  scoped_ptr<PresentationSessionMessage> scoped_test_message(test_message);
+  std::unique_ptr<PresentationSessionMessage> scoped_test_message(test_message);
   EXPECT_TRUE(test_message);
   EXPECT_TRUE(test_message->is_binary());
   EXPECT_EQ(PresentationMessageType::ARRAY_BUFFER, test_message->type);
   EXPECT_TRUE(test_message->message.empty());
   ASSERT_TRUE(test_message->data);
   EXPECT_EQ(data.size(), test_message->data->size());
   EXPECT_LE(test_message->data->size(), kMaxPresentationSessionMessageSize);
   EXPECT_EQ(0, memcmp(buffer, &(*test_message->data)[0], sizeof(buffer)));
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
@@ skipping 52 matching lines @@
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   // Make sure |test_message| gets deleted.
-  scoped_ptr<PresentationSessionMessage> scoped_test_message(test_message);
+  std::unique_ptr<PresentationSessionMessage> scoped_test_message(test_message);
   EXPECT_TRUE(test_message);
   EXPECT_TRUE(test_message->is_binary());
   EXPECT_EQ(PresentationMessageType::BLOB, test_message->type);
   EXPECT_TRUE(test_message->message.empty());
   ASSERT_TRUE(test_message->data);
   EXPECT_EQ(data.size(), test_message->data->size());
   EXPECT_LE(test_message->data->size(), kMaxPresentationSessionMessageSize);
   EXPECT_EQ(0, memcmp(buffer, &(*test_message->data)[0], sizeof(buffer)));
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
@@ skipping 27 matching lines @@
   mock_delegate_.set_screen_availability_listening_supported(false);
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_,
               OnScreenAvailabilityNotSupported(Eq(kPresentationUrl)))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   ListenForScreenAvailabilityAndWait(kPresentationUrl, false);
   run_loop.Run();
 }
 
 }  // namespace content