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

ui/events/platform/platform_event_source_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/events/platform/platform_event_source.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_observer.h"
 #include "ui/events/platform/scoped_event_dispatcher.h"
 
 namespace ui {
 
 namespace {
 
 scoped_ptr<PlatformEvent> CreatePlatformEvent() {
   scoped_ptr<PlatformEvent> event(new PlatformEvent());
   memset(event.get(), 0, sizeof(PlatformEvent));
-  return event.Pass();
+  return event;
 }
 
 template <typename T>
 void DestroyScopedPtr(scoped_ptr<T> object) {}
 
 void RemoveDispatcher(PlatformEventDispatcher* dispatcher) {
   PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(dispatcher);
 }
 
 void RemoveDispatchers(PlatformEventDispatcher* first,
@@ skipping 522 matching lines @@
 
 // This dispatcher destroys the handle to the ScopedEventDispatcher when
 // dispatching an event.
 class DestroyScopedHandleDispatcher : public TestPlatformEventDispatcher {
  public:
   DestroyScopedHandleDispatcher(int id, std::vector<int>* list)
       : TestPlatformEventDispatcher(id, list) {}
   ~DestroyScopedHandleDispatcher() override {}
 
   void SetScopedHandle(scoped_ptr<ScopedEventDispatcher> handler) {
-    handler_ = handler.Pass();
+    handler_ = std::move(handler);
   }
 
   void set_callback(const base::Closure& callback) {
     callback_ = callback;
   }
 
  private:
   // PlatformEventDispatcher:
   bool CanDispatchEvent(const PlatformEvent& event) override { return true; }
 
@@ skipping 16 matching lines @@
 // Tests that resetting an overridden dispatcher causes the nested message-loop
 // iteration to stop and the rest of the events are dispatched in the next
 // iteration.
 class DestroyedNestedOverriddenDispatcherQuitsNestedLoopIteration
     : public PlatformEventTestWithMessageLoop {
  public:
   void NestedTask(std::vector<int>* list,
                   TestPlatformEventDispatcher* dispatcher) {
     ScopedVector<PlatformEvent> events;
     scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
-    events.push_back(event.Pass());
+    events.push_back(std::move(event));
     event = CreatePlatformEvent();
-    events.push_back(event.Pass());
+    events.push_back(std::move(event));
 
     // Attempt to dispatch a couple of events. Dispatching the first event will
     // have terminated the ScopedEventDispatcher object, which will terminate
     // the current iteration of the message-loop.
     size_t count = source()->DispatchEventStream(events);
     EXPECT_EQ(1u, count);
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(20, (*list)[1]);
     list->clear();
@@ skipping 23 matching lines @@
     scoped_ptr<ScopedEventDispatcher> override_handle =
         source()->OverrideDispatcher(&overriding);
 
     scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
     source()->Dispatch(*event);
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(20, list[1]);
     list.clear();
 
-    overriding.SetScopedHandle(override_handle.Pass());
+    overriding.SetScopedHandle(std::move(override_handle));
     base::RunLoop run_loop;
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
     loop->PostTask(
         FROM_HERE,
         base::Bind(
             &DestroyedNestedOverriddenDispatcherQuitsNestedLoopIteration::
                 NestedTask,
             base::Unretained(this),
             base::Unretained(&list),
@@ skipping 40 matching lines @@
     source()->RemovePlatformEventDispatcher(&second_overriding);
     scoped_ptr<ScopedEventDispatcher> second_override_handle =
         source()->OverrideDispatcher(&second_overriding);
 
     source()->Dispatch(*event);
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(70, (*list)[1]);
     list->clear();
 
-    second_overriding.SetScopedHandle(second_override_handle.Pass());
+    second_overriding.SetScopedHandle(std::move(second_override_handle));
     second_overriding.set_post_dispatch_action(POST_DISPATCH_NONE);
     base::RunLoop run_loop;
     second_overriding.set_callback(run_loop.QuitClosure());
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
     loop->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&TestPlatformEventSource::Dispatch),
                    base::Unretained(source()),
                    *event));
@@ skipping 46 matching lines @@
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(10, list[1]);
   }
 };
 
 RUN_TEST_IN_MESSAGE_LOOP(
     ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration)
 
 }  // namespace ui