Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/wayland/fake_server.cc

 // Copyright 2016 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 "ui/ozone/platform/wayland/fake_server.h"
 
 #include <sys/socket.h>
 #include <wayland-server.h>
 #include <xdg-shell-unstable-v5-server-protocol.h>
 
 #include "base/bind.h"
 #include "base/files/scoped_file.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 
 namespace wl {
 namespace {
 
 const uint32_t kCompositorVersion = 4;
 const uint32_t kSeatVersion = 4;
 const uint32_t kXdgShellVersion = 1;
 
 void DestroyResource(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 // wl_compositor
 
 void CreateSurface(wl_client* client, wl_resource* resource, uint32_t id) {
   auto compositor =
       static_cast<MockCompositor*>(wl_resource_get_user_data(resource));
   wl_resource* surface_resource = wl_resource_create(
       client, &wl_surface_interface, wl_resource_get_version(resource), id);
   if (!surface_resource) {
     wl_client_post_no_memory(client);
     return;
   }
-  compositor->AddSurface(make_scoped_ptr(new MockSurface(surface_resource)));
+  compositor->AddSurface(base::WrapUnique(new MockSurface(surface_resource)));
 }
 
 const struct wl_compositor_interface compositor_impl = {
     &CreateSurface,  // create_surface
     nullptr,         // create_region
 };
 
 // wl_surface
 
 void Attach(wl_client* client,
@@ skipping 235 matching lines @@
   auto global = static_cast<Global*>(wl_resource_get_user_data(resource));
   if (global->resource_ == resource)
     global->resource_ = nullptr;
 }
 
 MockCompositor::MockCompositor()
     : Global(&wl_compositor_interface, &compositor_impl, kCompositorVersion) {}
 
 MockCompositor::~MockCompositor() {}
 
-void MockCompositor::AddSurface(scoped_ptr<MockSurface> surface) {
+void MockCompositor::AddSurface(std::unique_ptr<MockSurface> surface) {
   surfaces_.push_back(std::move(surface));
 }
 
 MockSeat::MockSeat() : Global(&wl_seat_interface, &seat_impl, kSeatVersion) {}
 
 MockSeat::~MockSeat() {}
 
 MockXdgShell::MockXdgShell()
     : Global(&xdg_shell_interface, &xdg_shell_impl, kXdgShellVersion) {}
 
@@ skipping 61 matching lines @@
     wl_display_flush_clients(display_.get());
   resume_event_.Signal();
 }
 
 void FakeServer::DoPause() {
   base::RunLoop().RunUntilIdle();
   pause_event_.Signal();
   resume_event_.Wait();
 }
 
-scoped_ptr<base::MessagePump> FakeServer::CreateMessagePump() {
-  auto pump = make_scoped_ptr(new base::MessagePumpLibevent);
+std::unique_ptr<base::MessagePump> FakeServer::CreateMessagePump() {
+  auto pump = base::WrapUnique(new base::MessagePumpLibevent);
   pump->WatchFileDescriptor(wl_event_loop_get_fd(event_loop_), true,
                             base::MessagePumpLibevent::WATCH_READ, &controller_,
                             this);
   return std::move(pump);
 }
 
 void FakeServer::OnFileCanReadWithoutBlocking(int fd) {
   wl_event_loop_dispatch(event_loop_, 0);
   wl_display_flush_clients(display_.get());
 }
 
 void FakeServer::OnFileCanWriteWithoutBlocking(int fd) {}
 
 }  // namespace wl