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

components/mus/public/cpp/lib/window_tree_client_impl.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/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 437 matching lines @@
     if (pair.second->window() == change.window() &&
         pair.second->change_type() == change.change_type() &&
         pair.second->Matches(change)) {
       return pair.second.get();
     }
   }
   return nullptr;
 }
 
 uint32_t WindowTreeClientImpl::ScheduleInFlightChange(
-    scoped_ptr<InFlightChange> change) {
+    std::unique_ptr<InFlightChange> change) {
   DCHECK(!change->window() ||
          windows_.count(change->window()->server_id()) > 0);
   const uint32_t change_id = next_change_id_++;
   in_flight_map_[change_id] = std::move(change);
   return change_id;
 }
 
 bool WindowTreeClientImpl::ApplyServerChangeToExistingInFlightChange(
     const InFlightChange& change) {
   InFlightChange* existing_change = GetOldestInFlightChangeMatching(change);
@@ skipping 167 matching lines @@
   // of the window at the time the server created it. For properties we do not
   // have changes in flight for we can update them immediately. For properties
   // with changes in flight we set the revert value from the server.
 
   if (!in_flight_map_.count(change_id)) {
     // The window may have been destroyed locally before the server could finish
     // creating the window, and before the server received the notification that
     // the window has been destroyed.
     return;
   }
-  scoped_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
+  std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
 
   Window* window = change->window();
   WindowPrivate window_private(window);
 
   // Drawn state and ViewportMetrics always come from the server (they can't
   // be modified locally).
   window_private.LocalSetParentDrawn(drawn);
   window_private.LocalSetViewportMetrics(mojom::ViewportMetrics(),
                                          *data->viewport_metrics);
@@ skipping 208 matching lines @@
 
 void WindowTreeClientImpl::OnWindowInputEvent(uint32_t event_id,
                                               Id window_id,
                                               mojom::EventPtr event) {
   Window* window = GetWindowByServerId(window_id);
   if (!window || !window->input_event_handler_) {
     tree_->OnWindowInputEventAck(event_id, mojom::EventResult::UNHANDLED);
     return;
   }
 
-  scoped_ptr<base::Callback<void(mojom::EventResult)>> ack_callback(
+  std::unique_ptr<base::Callback<void(mojom::EventResult)>> ack_callback(
       new base::Callback<void(mojom::EventResult)>(
           base::Bind(&mojom::WindowTree::OnWindowInputEventAck,
                      base::Unretained(tree_), event_id)));
   window->input_event_handler_->OnWindowInputEvent(
-      window, *event.To<scoped_ptr<ui::Event>>().get(), &ack_callback);
+      window, *event.To<std::unique_ptr<ui::Event>>().get(), &ack_callback);
 
   // The handler did not take ownership of the callback, so we send the ack,
   // marking the event as not consumed.
   if (ack_callback)
     ack_callback->Run(mojom::EventResult::UNHANDLED);
 }
 
 void WindowTreeClientImpl::OnWindowFocused(Id focused_window_id) {
   Window* focused_window = GetWindowByServerId(focused_window_id);
   InFlightFocusChange new_change(this, focused_window);
@@ skipping 11 matching lines @@
     return;
 
   InFlightPredefinedCursorChange new_change(window, cursor);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetPredefinedCursor(cursor);
 }
 
 void WindowTreeClientImpl::OnChangeCompleted(uint32_t change_id, bool success) {
-  scoped_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
+  std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
   if (!change)
     return;
 
   if (!success)
     change->ChangeFailed();
 
   InFlightChange* next_change = GetOldestInFlightChangeMatching(*change);
   if (next_change) {
     if (!success)
@@ skipping 39 matching lines @@
 }
 
 void WindowTreeClientImpl::WmSetProperty(uint32_t change_id,
                                          Id window_id,
                                          const mojo::String& name,
                                          mojo::Array<uint8_t> transit_data) {
   Window* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
-    scoped_ptr<std::vector<uint8_t>> data;
+    std::unique_ptr<std::vector<uint8_t>> data;
     if (!transit_data.is_null()) {
       data.reset(
           new std::vector<uint8_t>(transit_data.To<std::vector<uint8_t>>()));
     }
     result = window_manager_delegate_->OnWmSetProperty(window, name, &data);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       window->SetSharedPropertyInternal(name, data.get());
     }
   }
   window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClientImpl::WmCreateTopLevelWindow(
     uint32_t change_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties =
       transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
   Window* window =
       window_manager_delegate_->OnWmCreateTopLevelWindow(&properties);
   window_manager_internal_client_->OnWmCreatedTopLevelWindow(change_id,
                                                              server_id(window));
 }
 
 void WindowTreeClientImpl::OnAccelerator(uint32_t id, mojom::EventPtr event) {
   window_manager_delegate_->OnAccelerator(
-      id, *event.To<scoped_ptr<ui::Event>>().get());
+      id, *event.To<std::unique_ptr<ui::Event>>().get());
 }
 
 void WindowTreeClientImpl::SetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
   window_manager_internal_client_->WmSetFrameDecorationValues(
       std::move(values));
 }
 
 void WindowTreeClientImpl::AddAccelerator(
     uint32_t id,
@@ skipping 21 matching lines @@
 
 void WindowTreeClientImpl::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
       server_id(window), offset.x(), offset.y(), mojo::Insets::From(hit_area));
 }
 
 }  // namespace mus