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

content/child/shared_memory_data_consumer_handle.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 "content/child/shared_memory_data_consumer_handle.h"
 
 #include <algorithm>
 #include <deque>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/public/child/fixed_received_data.h"
 
 namespace content {
 
 namespace {
 
 class DelegateThreadSafeReceivedData final
     : public RequestPeer::ThreadSafeReceivedData {
  public:
   explicit DelegateThreadSafeReceivedData(
       scoped_ptr<RequestPeer::ReceivedData> data)
-      : data_(data.Pass()), task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
+      : data_(std::move(data)),
+        task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
   ~DelegateThreadSafeReceivedData() override {
     if (!task_runner_->BelongsToCurrentThread()) {
       // Delete the data on the original thread.
       task_runner_->DeleteSoon(FROM_HERE, data_.release());
     }
   }
 
   const char* payload() const override { return data_->payload(); }
   int length() const override { return data_->length(); }
   int encoded_length() const override { return data_->encoded_length(); }
@@ skipping 258 matching lines @@
     base::AutoLock lock(context_->lock());
     if (!context_->is_handle_active() && !context_->is_handle_locked()) {
       // No one is interested in the data.
       return;
     }
 
     needs_notification = context_->IsEmpty();
     scoped_ptr<RequestPeer::ThreadSafeReceivedData> data_to_pass;
     if (mode_ == kApplyBackpressure) {
       data_to_pass =
-          make_scoped_ptr(new DelegateThreadSafeReceivedData(data.Pass()));
+          make_scoped_ptr(new DelegateThreadSafeReceivedData(std::move(data)));
     } else {
       data_to_pass = make_scoped_ptr(new FixedReceivedData(data.get()));
     }
-    context_->Push(data_to_pass.Pass());
+    context_->Push(std::move(data_to_pass));
   }
 
   if (needs_notification) {
     // We CAN issue the notification synchronously if the associated reader
     // lives in this thread, because this function cannot be called in the
     // client's callback.
     context_->Notify();
   }
 }
 
@@ skipping 152 matching lines @@
 SharedMemoryDataConsumerHandle::ReaderImpl*
 SharedMemoryDataConsumerHandle::obtainReaderInternal(Client* client) {
   return new ReaderImpl(context_, client);
 }
 
 const char* SharedMemoryDataConsumerHandle::debugName() const {
   return "SharedMemoryDataConsumerHandle";
 }
 
 }  // namespace content