Convert Pass()→std::move() in //components (Android edition)

components/data_usage/android/traffic_stats_amortizer.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 "components/data_usage/android/traffic_stats_amortizer.h"
 
 #include <algorithm>  // For std::min.
 #include <cmath>      // For std::modf.
+#include <utility>
 
 #include "base/location.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/default_tick_clock.h"
 #include "base/timer/timer.h"
 #include "components/data_usage/core/data_use.h"
 #include "net/android/traffic_stats.h"
 
 namespace data_usage {
@@ skipping 123 matching lines @@
     scoped_ptr<DataUse> data_use,
     const AmortizationCompleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   int64_t tx_bytes = data_use->tx_bytes, rx_bytes = data_use->rx_bytes;
 
   // TODO(sclittle): Combine consecutive buffered DataUse objects that are
   // identical except for byte counts and have the same callback.
   buffered_data_use_.push_back(
       std::pair<scoped_ptr<DataUse>, AmortizationCompleteCallback>(
-          data_use.Pass(), callback));
+          std::move(data_use), callback));
 
   AddPreAmortizationBytes(tx_bytes, rx_bytes);
 }
 
 void TrafficStatsAmortizer::OnExtraBytes(int64_t extra_tx_bytes,
                                          int64_t extra_rx_bytes) {
   DCHECK(thread_checker_.CalledOnValidThread());
   AddPreAmortizationBytes(extra_tx_bytes, extra_rx_bytes);
 }
 
 base::WeakPtr<TrafficStatsAmortizer> TrafficStatsAmortizer::GetWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 TrafficStatsAmortizer::TrafficStatsAmortizer(
     scoped_ptr<base::TickClock> tick_clock,
     scoped_ptr<base::Timer> traffic_stats_query_timer,
     const base::TimeDelta& traffic_stats_query_delay,
     const base::TimeDelta& max_amortization_delay,
     size_t max_data_use_buffer_size)
-    : tick_clock_(tick_clock.Pass()),
-      traffic_stats_query_timer_(traffic_stats_query_timer.Pass()),
+    : tick_clock_(std::move(tick_clock)),
+      traffic_stats_query_timer_(std::move(traffic_stats_query_timer)),
       traffic_stats_query_delay_(traffic_stats_query_delay),
       max_amortization_delay_(max_amortization_delay),
       max_data_use_buffer_size_(max_data_use_buffer_size),
       is_amortization_in_progress_(false),
       are_last_amortization_traffic_stats_available_(false),
       last_amortization_traffic_stats_tx_bytes_(-1),
       last_amortization_traffic_stats_rx_bytes_(-1),
       pre_amortization_tx_bytes_(0),
       pre_amortization_rx_bytes_(0),
       weak_ptr_factory_(this) {}
@@ skipping 135 matching lines @@
       are_current_traffic_stats_available;
 
   pre_amortization_tx_bytes_ = 0;
   pre_amortization_rx_bytes_ = 0;
 
   DataUseBuffer data_use_sequence;
   data_use_sequence.swap(buffered_data_use_);
 
   // Pass post-amortization DataUse objects to their respective callbacks.
   for (auto& data_use_buffer_pair : data_use_sequence)
-    data_use_buffer_pair.second.Run(data_use_buffer_pair.first.Pass());
+    data_use_buffer_pair.second.Run(std::move(data_use_buffer_pair.first));
 }
 
 }  // namespace android
 }  // namespace data_usage