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

content/browser/memory/memory_pressure_controller_impl_browsertest.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 "base/bind.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "content/browser/memory/memory_message_filter.h"
 #include "content/browser/memory/memory_pressure_controller_impl.h"
 #include "content/common/memory_messages.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "ipc/ipc_message.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace content {
 
 MATCHER_P(IsSetSuppressedMessage, suppressed, "") {
   // Ensure that the message is deleted upon return.
-  scoped_ptr<IPC::Message> message(arg);
+  std::unique_ptr<IPC::Message> message(arg);
   if (message == nullptr)
     return false;
   MemoryMsg_SetPressureNotificationsSuppressed::Param param;
   if (!MemoryMsg_SetPressureNotificationsSuppressed::Read(message.get(),
                                                           &param))
     return false;
   return suppressed == base::get<0>(param);
 }
 
 MATCHER_P(IsSimulateMessage, level, "") {
   // Ensure that the message is deleted upon return.
-  scoped_ptr<IPC::Message> message(arg);
+  std::unique_ptr<IPC::Message> message(arg);
   if (message == nullptr)
     return false;
   MemoryMsg_SimulatePressureNotification::Param param;
   if (!MemoryMsg_SimulatePressureNotification::Read(message.get(), &param))
     return false;
   return level == base::get<0>(param);
 }
 
 MATCHER_P(IsPressureMessage, level, "") {
   // Ensure that the message is deleted upon return.
-  scoped_ptr<IPC::Message> message(arg);
+  std::unique_ptr<IPC::Message> message(arg);
   if (message == nullptr)
     return false;
   MemoryMsg_PressureNotification::Param param;
   if (!MemoryMsg_PressureNotification::Read(message.get(), &param))
     return false;
   return level == base::get<0>(param);
 }
 
 class MemoryMessageFilterForTesting : public MemoryMessageFilter {
  public:
@@ skipping 155 matching lines @@
   filter2->Remove();
   SetPressureNotificationsSuppressedInAllProcessesAndWait(false);
   EXPECT_FALSE(base::MemoryPressureListener::AreNotificationsSuppressed());
   testing::Mock::VerifyAndClearExpectations(this);
 }
 
 IN_PROC_BROWSER_TEST_F(MemoryPressureControllerImplBrowserTest,
                        SimulatePressureNotificationInAllProcesses) {
   scoped_refptr<MemoryMessageFilterForTesting> filter(
       new MemoryMessageFilterForTesting);
-  scoped_ptr<base::MemoryPressureListener> listener(
+  std::unique_ptr<base::MemoryPressureListener> listener(
       new base::MemoryPressureListener(
           base::Bind(&MemoryPressureControllerImplBrowserTest::OnMemoryPressure,
                      base::Unretained(this))));
 
   NavigateToURL(shell(), GetTestUrl("", "title.html"));
 
   filter->Add();
 
   // Send a memory pressure event to the first child process. It should send a
   // pressure notification message.
@@ skipping 35 matching lines @@
   EXPECT_CALL(*this, OnMemoryPressure(MEMORY_PRESSURE_LEVEL_MODERATE)).Times(1);
   SimulatePressureNotificationInAllProcessesAndWait(
       MEMORY_PRESSURE_LEVEL_MODERATE);
   RunAllPendingInMessageLoop();  // Wait for the listener to run.
   testing::Mock::VerifyAndClearExpectations(this);
 
   filter->Remove();
 }
 
 }  // namespace content