Replace scoped_ptr with std::unique_ptr in //ui

ui/aura/window.cc

 // Copyright (c) 2012 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/aura/window.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/visibility_client.h"
 #include "ui/aura/client/window_stacking_client.h"
@@ skipping 258 matching lines @@
   if (!layout_manager)
     return;
   // If we're changing to a new layout manager, ensure it is aware of all the
   // existing child windows.
   for (Windows::const_iterator it = children_.begin();
        it != children_.end();
        ++it)
     layout_manager_->OnWindowAddedToLayout(*it);
 }
 
-scoped_ptr<ui::EventTargeter>
-Window::SetEventTargeter(scoped_ptr<ui::EventTargeter> targeter) {
-  scoped_ptr<ui::EventTargeter> old_targeter = std::move(targeter_);
+std::unique_ptr<ui::EventTargeter> Window::SetEventTargeter(
+    std::unique_ptr<ui::EventTargeter> targeter) {
+  std::unique_ptr<ui::EventTargeter> old_targeter = std::move(targeter_);
   targeter_ = std::move(targeter);
   return old_targeter;
 }
 
 void Window::SetBounds(const gfx::Rect& new_bounds) {
   if (parent_ && parent_->layout_manager())
     parent_->layout_manager()->SetChildBounds(this, new_bounds);
   else {
     // Ensure we don't go smaller than our minimum bounds.
     gfx::Rect final_bounds(new_bounds);
@@ skipping 772 matching lines @@
 
 ui::EventTarget* Window::GetParentTarget() {
   if (IsRootWindow()) {
     return client::GetEventClient(this) ?
         client::GetEventClient(this)->GetToplevelEventTarget() :
             Env::GetInstance();
   }
   return parent_;
 }
 
-scoped_ptr<ui::EventTargetIterator> Window::GetChildIterator() const {
-  return make_scoped_ptr(new ui::EventTargetIteratorImpl<Window>(children()));
+std::unique_ptr<ui::EventTargetIterator> Window::GetChildIterator() const {
+  return base::WrapUnique(new ui::EventTargetIteratorImpl<Window>(children()));
 }
 
 ui::EventTargeter* Window::GetEventTargeter() {
   return targeter_.get();
 }
 
 void Window::ConvertEventToTarget(ui::EventTarget* target,
                                   ui::LocatedEvent* event) {
   event->ConvertLocationToTarget(this,
                                  static_cast<Window*>(target));
 }
 
 void Window::UpdateLayerName() {
 #if !defined(NDEBUG)
   DCHECK(layer());
 
   std::string layer_name(name_);
   if (layer_name.empty())
     layer_name = "Unnamed Window";
 
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura