Convert Pass()→std::move() in ui/

ui/events/scoped_target_handler_unittest.cc

 // Copyright 2015 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/events/scoped_target_handler.h"
 
+#include <utility>
+
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/event_target.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/events/event_utils.h"
 
 namespace ui {
 
 namespace {
@@ skipping 10 matching lines @@
 };
 
 // An EventTarget that holds ownership of its target and delegate EventHandlers.
 class TestEventTarget : public EventTarget {
  public:
   TestEventTarget() {}
   ~TestEventTarget() override {}
 
   void SetHandler(scoped_ptr<EventHandler> target_handler,
                   scoped_ptr<EventHandler> delegate) {
-    target_handler_ = target_handler.Pass();
-    delegate_ = delegate.Pass();
+    target_handler_ = std::move(target_handler);
+    delegate_ = std::move(delegate);
   }
 
   // EventTarget:
   void DispatchEvent(Event* event) { target_handler()->OnEvent(event); }
   bool CanAcceptEvent(const Event& event) override { return true; }
   EventTarget* GetParentTarget() override { return nullptr; }
   scoped_ptr<EventTargetIterator> GetChildIterator() const override {
     return make_scoped_ptr(new TestEventTargetIterator);
   }
   EventTargeter* GetEventTargeter() override { return nullptr; }
@@ skipping 86 matching lines @@
 }  // namespace
 
 // Tests that a ScopedTargetHandler invokes both the target and a delegate.
 TEST(ScopedTargetHandlerTest, HandlerInvoked) {
   int count = 0;
   TestEventTarget* target = new TestEventTarget;
   scoped_ptr<NestedEventHandler> target_handler(
       new NestedEventHandler(target, 1));
   scoped_ptr<EventCountingEventHandler> delegate(
       new EventCountingEventHandler(target, &count));
-  target->SetHandler(target_handler.Pass(), delegate.Pass());
+  target->SetHandler(std::move(target_handler), std::move(delegate));
   MouseEvent event(ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                    EventTimeForNow(), EF_LEFT_MOUSE_BUTTON,
                    EF_LEFT_MOUSE_BUTTON);
   target->DispatchEvent(&event);
   EXPECT_EQ(1, count);
   delete target;
 }
 
 // Tests that a ScopedTargetHandler invokes both the target and a delegate when
 // an Event is dispatched recursively such as with synthetic events.
 TEST(ScopedTargetHandlerTest, HandlerInvokedNested) {
   int count = 0;
   TestEventTarget* target = new TestEventTarget;
   scoped_ptr<NestedEventHandler> target_handler(
       new NestedEventHandler(target, 2));
   scoped_ptr<EventCountingEventHandler> delegate(
       new EventCountingEventHandler(target, &count));
-  target->SetHandler(target_handler.Pass(), delegate.Pass());
+  target->SetHandler(std::move(target_handler), std::move(delegate));
   MouseEvent event(ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                    EventTimeForNow(), EF_LEFT_MOUSE_BUTTON,
                    EF_LEFT_MOUSE_BUTTON);
   target->DispatchEvent(&event);
   EXPECT_EQ(2, count);
   delete target;
 }
 
 // Tests that a it is safe to delete a ScopedTargetHandler while handling an
 // event.
 TEST(ScopedTargetHandlerTest, SafeToDestroy) {
   int count = 0;
   TestEventTarget* target = new TestEventTarget;
   scoped_ptr<TargetDestroyingEventHandler> target_handler(
       new TargetDestroyingEventHandler(target, 1));
   scoped_ptr<EventCountingEventHandler> delegate(
       new EventCountingEventHandler(target, &count));
-  target->SetHandler(target_handler.Pass(), delegate.Pass());
+  target->SetHandler(std::move(target_handler), std::move(delegate));
   MouseEvent event(ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                    EventTimeForNow(), EF_LEFT_MOUSE_BUTTON,
                    EF_LEFT_MOUSE_BUTTON);
   target->DispatchEvent(&event);
   EXPECT_EQ(0, count);
 }
 
 // Tests that a it is safe to delete a ScopedTargetHandler while handling an
 // event recursively.
 TEST(ScopedTargetHandlerTest, SafeToDestroyNested) {
   int count = 0;
   TestEventTarget* target = new TestEventTarget;
   scoped_ptr<TargetDestroyingEventHandler> target_handler(
       new TargetDestroyingEventHandler(target, 2));
   scoped_ptr<EventCountingEventHandler> delegate(
       new EventCountingEventHandler(target, &count));
-  target->SetHandler(target_handler.Pass(), delegate.Pass());
+  target->SetHandler(std::move(target_handler), std::move(delegate));
   MouseEvent event(ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                    EventTimeForNow(), EF_LEFT_MOUSE_BUTTON,
                    EF_LEFT_MOUSE_BUTTON);
   target->DispatchEvent(&event);
   EXPECT_EQ(0, count);
 }
 
 }  // namespace ui