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

ui/events/gesture_detection/motion_event_buffer.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/gesture_detection/motion_event_buffer.h"
 
+#include <utility>
+
 #include "base/trace_event/trace_event.h"
 #include "ui/events/gesture_detection/motion_event_generic.h"
 
 namespace ui {
 namespace {
 
 // Latency added during resampling. A few milliseconds doesn't hurt much but
 // reduces the impact of mispredicted touch positions.
 const int kResampleLatencyMs = 5;
 
@@ skipping 48 matching lines @@
 
 MotionEventVector ConsumeSamplesNoLaterThan(MotionEventVector* batch,
                                             base::TimeTicks time) {
   DCHECK(batch);
   size_t count = CountSamplesNoLaterThan(*batch, time);
   DCHECK_GE(batch->size(), count);
   if (count == 0)
     return MotionEventVector();
 
   if (count == batch->size())
-    return batch->Pass();
+    return std::move(*batch);
 
   // TODO(jdduke): Use a ScopedDeque to work around this mess.
   MotionEventVector unconsumed_batch;
   unconsumed_batch.insert(
       unconsumed_batch.begin(), batch->begin() + count, batch->end());
   batch->weak_erase(batch->begin() + count, batch->end());
 
   unconsumed_batch.swap(*batch);
   DCHECK_GE(unconsumed_batch.size(), 1U);
-  return unconsumed_batch.Pass();
+  return unconsumed_batch;
 }
 
 // Linearly interpolate the pointer position between two MotionEvent samples.
 // Only pointers of finger or unknown type will be resampled.
 PointerProperties ResamplePointer(const MotionEvent& event0,
                                   const MotionEvent& event1,
                                   size_t event0_pointer_index,
                                   size_t event1_pointer_index,
                                   float alpha) {
   DCHECK_EQ(event0.GetPointerId(event0_pointer_index),
@@ skipping 44 matching lines @@
     if (event0_i == 0) {
       event.reset(new MotionEventGeneric(
           MotionEvent::ACTION_MOVE, resample_time, pointer));
     } else {
       event->PushPointer(pointer);
     }
   }
 
   DCHECK(event);
   event->set_button_state(event0.GetButtonState());
-  return event.Pass();
+  return event;
 }
 
 // Synthesize a compound MotionEventGeneric event from a sequence of events.
 // Events must be in non-decreasing (time) order.
 scoped_ptr<MotionEventGeneric> ConsumeSamples(MotionEventVector events) {
   DCHECK(!events.empty());
   scoped_ptr<MotionEventGeneric> event(events.back());
   for (size_t i = 0; i + 1 < events.size(); ++i)
     event->PushHistoricalEvent(scoped_ptr<MotionEvent>(events[i]));
   events.weak_clear();
-  return event.Pass();
+  return event;
 }
 
 // Consume a series of event samples, attempting to synthesize a new, synthetic
 // event if the samples and sample time meet certain interpolation/extrapolation
 // conditions. If such conditions are met, the provided samples will be added
 // to the synthetic event's history, otherwise, the samples will be used to
 // generate a basic, compound event.
 // TODO(jdduke): Revisit resampling to handle cases where alternating frames
 // are resampled or resampling is otherwise inconsistent, e.g., a 90hz input
 // and 60hz frame signal could phase-align such that even frames yield an
@@ skipping 26 matching lines @@
                            "original(ms)",
                            (resample_time - time1).InMilliseconds(),
                            "adjusted(ms)",
                            (max_predict - time1).InMilliseconds());
       resample_time = max_predict;
     }
   } else {
     TRACE_EVENT_INSTANT0("input",
                          "MotionEventBuffer::TryResample insufficient data",
                          TRACE_EVENT_SCOPE_THREAD);
-    return ConsumeSamples(events.Pass());
+    return ConsumeSamples(std::move(events));
   }
 
   DCHECK(event0);
   DCHECK(event1);
   const base::TimeTicks time0 = event0->GetEventTime();
   const base::TimeTicks time1 = event1->GetEventTime();
   base::TimeDelta delta = time1 - time0;
   if (delta < base::TimeDelta::FromMilliseconds(kResampleMinDeltaMs)) {
     TRACE_EVENT_INSTANT1("input",
                          "MotionEventBuffer::TryResample failure",
                          TRACE_EVENT_SCOPE_THREAD,
                          "event_delta_too_small(ms)",
                          delta.InMilliseconds());
-    return ConsumeSamples(events.Pass());
+    return ConsumeSamples(std::move(events));
   }
 
   scoped_ptr<MotionEventGeneric> resampled_event =
       ResampleMotionEvent(*event0, *event1, resample_time);
   for (size_t i = 0; i < events.size(); ++i)
     resampled_event->PushHistoricalEvent(scoped_ptr<MotionEvent>(events[i]));
   events.weak_clear();
-  return resampled_event.Pass();
+  return resampled_event;
 }
 
 }  // namespace
 
 MotionEventBuffer::MotionEventBuffer(MotionEventBufferClient* client,
                                      bool enable_resampling)
     : client_(client), resample_(enable_resampling) {
 }
 
 MotionEventBuffer::~MotionEventBuffer() {
 }
 
 void MotionEventBuffer::OnMotionEvent(const MotionEvent& event) {
   DCHECK_EQ(0U, event.GetHistorySize());
   if (event.GetAction() != MotionEvent::ACTION_MOVE) {
     last_extrapolated_event_time_ = base::TimeTicks();
     if (!buffered_events_.empty())
-      FlushWithoutResampling(buffered_events_.Pass());
+      FlushWithoutResampling(std::move(buffered_events_));
     client_->ForwardMotionEvent(event);
     return;
   }
 
   // Guard against events that are *older* than the last one that may have been
   // artificially synthesized.
   if (!last_extrapolated_event_time_.is_null()) {
     DCHECK(buffered_events_.empty());
     if (event.GetEventTime() < last_extrapolated_event_time_)
       return;
     last_extrapolated_event_time_ = base::TimeTicks();
   }
 
   scoped_ptr<MotionEventGeneric> clone = MotionEventGeneric::CloneEvent(event);
   if (buffered_events_.empty()) {
-    buffered_events_.push_back(clone.Pass());
+    buffered_events_.push_back(std::move(clone));
     client_->SetNeedsFlush();
     return;
   }
 
   if (CanAddSample(*buffered_events_.front(), *clone)) {
     DCHECK(buffered_events_.back()->GetEventTime() <= clone->GetEventTime());
   } else {
-    FlushWithoutResampling(buffered_events_.Pass());
+    FlushWithoutResampling(std::move(buffered_events_));
   }
 
-  buffered_events_.push_back(clone.Pass());
+  buffered_events_.push_back(std::move(clone));
   // No need to request another flush as the first event will have requested it.
 }
 
 void MotionEventBuffer::Flush(base::TimeTicks frame_time) {
   if (buffered_events_.empty())
     return;
 
   // Shifting the sample time back slightly minimizes the potential for
   // misprediction when extrapolating events.
   if (resample_)
     frame_time -= base::TimeDelta::FromMilliseconds(kResampleLatencyMs);
 
   // TODO(jdduke): Use a persistent MotionEventVector vector for temporary
   // storage.
   MotionEventVector events(
       ConsumeSamplesNoLaterThan(&buffered_events_, frame_time));
   if (events.empty()) {
     DCHECK(!buffered_events_.empty());
     client_->SetNeedsFlush();
     return;
   }
 
   if (!resample_ || (events.size() == 1 && buffered_events_.empty())) {
-    FlushWithoutResampling(events.Pass());
+    FlushWithoutResampling(std::move(events));
     if (!buffered_events_.empty())
       client_->SetNeedsFlush();
     return;
   }
 
-  FlushWithResampling(events.Pass(), frame_time);
+  FlushWithResampling(std::move(events), frame_time);
 }
 
 void MotionEventBuffer::FlushWithResampling(MotionEventVector events,
                                             base::TimeTicks resample_time) {
   DCHECK(!events.empty());
   base::TimeTicks original_event_time = events.back()->GetEventTime();
   const MotionEvent* next_event =
       !buffered_events_.empty() ? buffered_events_.front() : nullptr;
 
   scoped_ptr<MotionEventGeneric> resampled_event =
-      ConsumeSamplesAndTryResampling(resample_time, events.Pass(), next_event);
+      ConsumeSamplesAndTryResampling(resample_time, std::move(events),
+                                     next_event);
   DCHECK(resampled_event);
 
   // Log the extrapolated event time, guarding against subsequently queued
   // events that might have an earlier timestamp.
   if (!next_event && resampled_event->GetEventTime() > original_event_time) {
     last_extrapolated_event_time_ = resampled_event->GetEventTime();
   } else {
     last_extrapolated_event_time_ = base::TimeTicks();
   }
 
   client_->ForwardMotionEvent(*resampled_event);
   if (!buffered_events_.empty())
     client_->SetNeedsFlush();
 }
 
 void MotionEventBuffer::FlushWithoutResampling(MotionEventVector events) {
   last_extrapolated_event_time_ = base::TimeTicks();
   if (events.empty())
     return;
 
-  client_->ForwardMotionEvent(*ConsumeSamples(events.Pass()));
+  client_->ForwardMotionEvent(*ConsumeSamples(std::move(events)));
 }
 
 }  // namespace ui