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

components/mus/ws/window_tree.cc

 // Copyright 2014 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/window_tree.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "components/mus/ws/default_access_policy.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "components/mus/ws/window_manager_state.h"
@@ skipping 19 matching lines @@
   TargetedEvent(ServerWindow* target, const ui::Event& event)
       : target_(target), event_(ui::Event::Clone(event)) {
     target_->AddObserver(this);
   }
   ~TargetedEvent() override {
     if (target_)
       target_->RemoveObserver(this);
   }
 
   ServerWindow* target() { return target_; }
-  scoped_ptr<ui::Event> TakeEvent() { return std::move(event_); }
+  std::unique_ptr<ui::Event> TakeEvent() { return std::move(event_); }
 
  private:
   // ServerWindowObserver:
   void OnWindowDestroyed(ServerWindow* window) override {
     DCHECK_EQ(target_, window);
     target_->RemoveObserver(this);
     target_ = nullptr;
   }
 
   ServerWindow* target_;
-  scoped_ptr<ui::Event> event_;
+  std::unique_ptr<ui::Event> event_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetedEvent);
 };
 
 WindowTree::WindowTree(WindowServer* window_server,
                        const UserId& user_id,
                        ServerWindow* root,
-                       scoped_ptr<AccessPolicy> access_policy)
+                       std::unique_ptr<AccessPolicy> access_policy)
     : window_server_(window_server),
       user_id_(user_id),
       id_(window_server_->GetAndAdvanceNextConnectionId()),
       next_window_id_(1),
       access_policy_(std::move(access_policy)),
       event_ack_id_(0),
       window_manager_internal_(nullptr) {
   if (root)
     roots_.insert(root);
   access_policy_->Init(id_, this);
 }
 
 WindowTree::~WindowTree() {
   DestroyWindows();
 }
 
-void WindowTree::Init(scoped_ptr<WindowTreeBinding> binding,
+void WindowTree::Init(std::unique_ptr<WindowTreeBinding> binding,
                       mojom::WindowTreePtr tree) {
   DCHECK(!binding_);
   binding_ = std::move(binding);
 
   if (roots_.empty())
     return;
 
   std::vector<const ServerWindow*> to_send;
   CHECK_EQ(1u, roots_.size());
   const ServerWindow* root = *roots_.begin();
@@ skipping 202 matching lines @@
 
 bool WindowTree::Embed(const ClientWindowId& window_id,
                        mojom::WindowTreeClientPtr client) {
   if (!client || !CanEmbed(window_id))
     return false;
   ServerWindow* window = GetWindowByClientId(window_id);
   PrepareForEmbed(window);
   // When embedding we don't know the user id of where the TreeClient came
   // from. Use an invalid id, which limits what the client is able to do.
   window_server_->EmbedAtWindow(window, InvalidUserId(), std::move(client),
-                                make_scoped_ptr(new DefaultAccessPolicy));
+                                base::WrapUnique(new DefaultAccessPolicy));
   return true;
 }
 
 void WindowTree::DispatchInputEvent(ServerWindow* target,
                                     const ui::Event& event) {
   if (event_ack_id_) {
     // This is currently waiting for an event ack. Add it to the queue.
-    event_queue_.push(make_scoped_ptr(new TargetedEvent(target, event)));
+    event_queue_.push(base::WrapUnique(new TargetedEvent(target, event)));
     // TODO(sad): If the |event_queue_| grows too large, then this should notify
     // Display, so that it can stop sending events.
     return;
   }
 
   // If there are events in the queue, then store this new event in the queue,
   // and dispatch the latest event from the queue instead that still has a live
   // target.
   if (!event_queue_.empty()) {
-    event_queue_.push(make_scoped_ptr(new TargetedEvent(target, event)));
+    event_queue_.push(base::WrapUnique(new TargetedEvent(target, event)));
     return;
   }
 
   DispatchInputEventImpl(target, event);
 }
 
 bool WindowTree::IsWaitingForNewTopLevelWindow(uint32_t wm_change_id) {
   return waiting_for_top_level_window_info_ &&
          waiting_for_top_level_window_info_->wm_change_id == wm_change_id;
 }
 
 void WindowTree::OnWindowManagerCreatedTopLevelWindow(
     uint32_t wm_change_id,
     uint32_t client_change_id,
     const ServerWindow* window) {
   DCHECK(IsWaitingForNewTopLevelWindow(wm_change_id));
-  scoped_ptr<WaitingForTopLevelWindowInfo> waiting_for_top_level_window_info(
-      std::move(waiting_for_top_level_window_info_));
+  std::unique_ptr<WaitingForTopLevelWindowInfo>
+      waiting_for_top_level_window_info(
+          std::move(waiting_for_top_level_window_info_));
   binding_->SetIncomingMethodCallProcessingPaused(false);
   // We were paused, so the id should still be valid.
   DCHECK(IsValidIdForNewWindow(
       waiting_for_top_level_window_info->client_window_id));
   client_id_to_window_id_map_[waiting_for_top_level_window_info
                                   ->client_window_id] = window->id();
   window_id_to_client_id_map_[window->id()] =
       waiting_for_top_level_window_info->client_window_id;
   roots_.insert(window);
   const bool drawn = window->parent() && window->parent()->IsDrawn();
@@ skipping 871 matching lines @@
   event_ack_id_ = 0;
 
   WindowManagerState* event_source_wms = event_source_wms_;
   event_source_wms_ = nullptr;
   if (event_source_wms)
     event_source_wms->OnEventAck(this, result);
 
   if (!event_queue_.empty()) {
     DCHECK(!event_ack_id_);
     ServerWindow* target = nullptr;
-    scoped_ptr<ui::Event> event;
+    std::unique_ptr<ui::Event> event;
     do {
-      scoped_ptr<TargetedEvent> targeted_event =
+      std::unique_ptr<TargetedEvent> targeted_event =
           std::move(event_queue_.front());
       event_queue_.pop();
       target = targeted_event->target();
       event = targeted_event->TakeEvent();
     } while (!event_queue_.empty() && !GetDisplay(target));
     if (target)
       DispatchInputEventImpl(target, *event);
   }
 }
 
@@ skipping 158 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus