Convert //components/mus from scoped_ptr to std::unique_ptr

components/mus/ws/test_utils.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 "components/mus/ws/test_utils.h"
 
+#include "base/memory/ptr_util.h"
 #include "cc/output/copy_output_request.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/display_binding.h"
 #include "components/mus/ws/window_manager_access_policy.h"
 #include "components/mus/ws/window_manager_factory_service.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
 
 namespace mus {
 namespace ws {
@@ skipping 27 matching lines @@
   void ReleaseCapture() override {}
   void SetCursorById(int32_t cursor) override { *cursor_id_storage_ = cursor; }
   mojom::Rotation GetRotation() override { return mojom::Rotation::VALUE_0; }
   const mojom::ViewportMetrics& GetViewportMetrics() override {
     return display_metrics_;
   }
   void UpdateTextInputState(const ui::TextInputState& state) override {}
   void SetImeVisibility(bool visible) override {}
   bool IsFramePending() const override { return false; }
   void RequestCopyOfOutput(
-      scoped_ptr<cc::CopyOutputRequest> output_request) override {}
+      std::unique_ptr<cc::CopyOutputRequest> output_request) override {}
 
  private:
   mojom::ViewportMetrics display_metrics_;
 
   int32_t* cursor_id_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformDisplay);
 };
 
 ClientWindowId NextUnusedClientWindowId(WindowTree* tree) {
@@ skipping 13 matching lines @@
 
 WindowManagerFactoryRegistryTestApi::WindowManagerFactoryRegistryTestApi(
     WindowManagerFactoryRegistry* registry)
     : registry_(registry) {}
 
 WindowManagerFactoryRegistryTestApi::~WindowManagerFactoryRegistryTestApi() {}
 
 void WindowManagerFactoryRegistryTestApi::AddService(
     const UserId& user_id,
     mojom::WindowManagerFactory* factory) {
-  scoped_ptr<WindowManagerFactoryService> service_ptr(
+  std::unique_ptr<WindowManagerFactoryService> service_ptr(
       new WindowManagerFactoryService(registry_, user_id));
   WindowManagerFactoryService* service = service_ptr.get();
   registry_->AddServiceImpl(std::move(service_ptr));
   service->SetWindowManagerFactoryImpl(factory);
 }
 
 // TestPlatformDisplayFactory  -------------------------------------------------
 
 TestPlatformDisplayFactory::TestPlatformDisplayFactory(
     int32_t* cursor_id_storage)
@@ skipping 24 matching lines @@
     if (pair.second.window == window)
       count++;
   return count;
 }
 
 // TestDisplayBinding ---------------------------------------------------------
 
 WindowTree* TestDisplayBinding::CreateWindowTree(ServerWindow* root) {
   return window_server_->EmbedAtWindow(
       root, shell::mojom::kRootUserID, mus::mojom::WindowTreeClientPtr(),
-      make_scoped_ptr(new WindowManagerAccessPolicy));
+      base::WrapUnique(new WindowManagerAccessPolicy));
 }
 
 // TestWindowManager ----------------------------------------------------------
 
 void TestWindowManager::WmCreateTopLevelWindow(
     uint32_t change_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> properties) {
   got_create_top_level_window_ = true;
   change_id_ = change_id;
 }
@@ skipping 159 matching lines @@
   // Display manages its own lifetime.
   Display* display = new Display(window_server_, PlatformDisplayInitParams());
   display->Init(nullptr);
   return display;
 }
 
 void TestWindowServerDelegate::OnNoMoreDisplays() {
   got_on_no_more_displays_ = true;
 }
 
-scoped_ptr<WindowTreeBinding> TestWindowServerDelegate::CreateWindowTreeBinding(
+std::unique_ptr<WindowTreeBinding>
+TestWindowServerDelegate::CreateWindowTreeBinding(
     BindingType type,
     ws::WindowServer* window_server,
     ws::WindowTree* tree,
     mojom::WindowTreeRequest* tree_request,
     mojom::WindowTreeClientPtr* client) {
-  scoped_ptr<TestWindowTreeBinding> binding(new TestWindowTreeBinding(tree));
+  std::unique_ptr<TestWindowTreeBinding> binding(
+      new TestWindowTreeBinding(tree));
   bindings_.push_back(binding.get());
   return std::move(binding);
 }
 
 void TestWindowServerDelegate::CreateDefaultDisplays() {
   DCHECK(num_displays_to_create_);
   DCHECK(window_server_);
 
   for (int i = 0; i < num_displays_to_create_; ++i)
     AddDisplay();
@@ skipping 37 matching lines @@
     return nullptr;
   if (!tree->AddWindow(parent_client_id, client_window_id))
     return nullptr;
   *client_id = client_window_id;
   return tree->GetWindowByClientId(client_window_id);
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus