Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/wayland/fake_server.h

 // 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.
 
 #ifndef UI_OZONE_PLATFORM_WAYLAND_FAKE_SERVER_H_
 #define UI_OZONE_PLATFORM_WAYLAND_FAKE_SERVER_H_
 
 #include <wayland-server-core.h>
 
 #include "base/bind.h"
@@ skipping 47 matching lines @@
   MockSurface(wl_resource* resource);
   ~MockSurface() override;
 
   static MockSurface* FromResource(wl_resource* resource);
 
   MOCK_METHOD3(Attach, void(wl_resource* buffer, int32_t x, int32_t y));
   MOCK_METHOD4(Damage,
                void(int32_t x, int32_t y, int32_t width, int32_t height));
   MOCK_METHOD0(Commit, void());
 
-  scoped_ptr<MockXdgSurface> xdg_surface;
+  std::unique_ptr<MockXdgSurface> xdg_surface;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSurface);
 };
 
 class MockPointer : public ServerObject {
  public:
   MockPointer(wl_resource* resource);
   ~MockPointer() override;
 
@@ skipping 18 matching lines @@
   // useful when testing a simple client.
   wl_resource* resource() { return resource_; }
 
   static void Bind(wl_client* client,
                    void* data,
                    uint32_t version,
                    uint32_t id);
   static void OnResourceDestroyed(wl_resource* resource);
 
  private:
-  scoped_ptr<wl_global, GlobalDeleter> global_;
+  std::unique_ptr<wl_global, GlobalDeleter> global_;
 
   const wl_interface* interface_;
   const void* implementation_;
   const uint32_t version_;
   wl_resource* resource_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(Global);
 };
 
 class MockCompositor : public Global {
  public:
   MockCompositor();
   ~MockCompositor() override;
 
-  void AddSurface(scoped_ptr<MockSurface> surface);
+  void AddSurface(std::unique_ptr<MockSurface> surface);
 
  private:
-  std::vector<scoped_ptr<MockSurface>> surfaces_;
+  std::vector<std::unique_ptr<MockSurface>> surfaces_;
 
   DISALLOW_COPY_AND_ASSIGN(MockCompositor);
 };
 
 class MockSeat : public Global {
  public:
   MockSeat();
   ~MockSeat() override;
 
-  scoped_ptr<MockPointer> pointer;
+  std::unique_ptr<MockPointer> pointer;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSeat);
 };
 
 class MockXdgShell : public Global {
  public:
   MockXdgShell();
   ~MockXdgShell() override;
 
@@ skipping 31 matching lines @@
     wl_resource* resource = wl_client_get_object(client_, id);
     return resource ? T::FromResource(resource) : nullptr;
   }
 
   MockSeat* seat() { return &seat_; }
   MockXdgShell* xdg_shell() { return &xdg_shell_; }
 
  private:
   void DoPause();
 
-  scoped_ptr<base::MessagePump> CreateMessagePump();
+  std::unique_ptr<base::MessagePump> CreateMessagePump();
 
   // base::MessagePumpLibevent::Watcher
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int fd) override;
 
-  scoped_ptr<wl_display, DisplayDeleter> display_;
+  std::unique_ptr<wl_display, DisplayDeleter> display_;
   wl_client* client_ = nullptr;
   wl_event_loop* event_loop_ = nullptr;
 
   base::WaitableEvent pause_event_;
   base::WaitableEvent resume_event_;
   bool paused_ = false;
 
   MockCompositor compositor_;
   MockSeat seat_;
   MockXdgShell xdg_shell_;
 
   base::MessagePumpLibevent::FileDescriptorWatcher controller_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeServer);
 };
 
 }  // namespace wl
 
 #endif  // UI_OZONE_PLATFORM_WAYLAND_FAKE_SERVER_H_