Replace scoped_ptr with std::unique_ptr in //ui

ui/chromeos/touch_exploration_controller_unittest.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 "ui/chromeos/touch_exploration_controller.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 159 matching lines @@
 
   float GetSlopDistanceFromEdge() const {
     return touch_exploration_controller_->kSlopDistanceFromEdge;
   }
 
   void SetTickClockForTesting(base::TickClock* simulated_clock) {
     touch_exploration_controller_->tick_clock_ = simulated_clock;
   }
 
  private:
-  scoped_ptr<TouchExplorationController> touch_exploration_controller_;
+  std::unique_ptr<TouchExplorationController> touch_exploration_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationControllerTestApi);
 };
 
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
   TouchExplorationTest() : simulated_clock_(new base::SimpleTestTickClock()) {
     // Tests fail if time is ever 0.
     simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
   }
   ~TouchExplorationTest() override {}
 
   void SetUp() override {
     if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
       gfx::GLSurfaceTestSupport::InitializeOneOff();
     aura::test::AuraTestBase::SetUp();
     cursor_client_.reset(new aura::test::TestCursorClient(root_window()));
     root_window()->AddPreTargetHandler(&event_capturer_);
     generator_.reset(new test::EventGenerator(root_window()));
     // The generator takes ownership of the tick clock.
-    generator_->SetTickClock(scoped_ptr<base::TickClock>(simulated_clock_));
+    generator_->SetTickClock(
+        std::unique_ptr<base::TickClock>(simulated_clock_));
     cursor_client()->ShowCursor();
     cursor_client()->DisableMouseEvents();
   }
 
   void TearDown() override {
     root_window()->RemovePreTargetHandler(&event_capturer_);
     SwitchTouchExplorationMode(false);
     cursor_client_.reset();
     aura::test::AuraTestBase::TearDown();
   }
@@ skipping 171 matching lines @@
     return touch_exploration_controller_->GetSlopDistanceFromEdge();
   }
 
   base::TimeDelta Now() {
     // This is the same as what EventTimeForNow() does, but here we do it
     // with our simulated clock.
     return base::TimeDelta::FromInternalValue(
         simulated_clock_->NowTicks().ToInternalValue());
   }
 
-  scoped_ptr<test::EventGenerator> generator_;
+  std::unique_ptr<test::EventGenerator> generator_;
   ui::GestureDetector::Config gesture_detector_config_;
   // Owned by |generator_|.
   base::SimpleTestTickClock* simulated_clock_;
   MockTouchExplorationControllerDelegate delegate_;
 
  private:
   EventCapturer event_capturer_;
-  scoped_ptr<TouchExplorationControllerTestApi>
+  std::unique_ptr<TouchExplorationControllerTestApi>
       touch_exploration_controller_;
-  scoped_ptr<aura::test::TestCursorClient> cursor_client_;
+  std::unique_ptr<aura::test::TestCursorClient> cursor_client_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationTest);
 };
 
 // Executes a number of assertions to confirm that |e1| and |e2| are touch
 // events and are equal to each other.
 void ConfirmEventsAreTouchAndEqual(ui::Event* e1, ui::Event* e2) {
   ASSERT_TRUE(e1->IsTouchEvent());
   ASSERT_TRUE(e2->IsTouchEvent());
   ui::TouchEvent* touch_event1 = e1->AsTouchEvent();
@@ skipping 1514 matching lines @@
     generator_->PressTouch();
     generator_->MoveTouch(initial_press);
     generator_->MoveTouch(*point);
     generator_->ReleaseTouch();
     ASSERT_EQ(1U, delegate_.NumExitScreenSounds());
     delegate_.ResetCountersToZero();
   }
 }
 
 }  // namespace ui