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

content/browser/tracing/tracing_controller_impl_data_sinks.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/browser/tracing/tracing_controller_impl.h"
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/strings/pattern.h"
+#include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/zlib/zlib.h"
 
 namespace content {
 
 namespace {
 
 const char kChromeTraceLabel[] = "traceEvents";
 const char kMetadataTraceLabel[] = "metadata";
 
 class StringTraceDataEndpoint : public TracingController::TraceDataEndpoint {
  public:
   typedef base::Callback<void(scoped_ptr<const base::DictionaryValue>,
                               base::RefCountedString*)> CompletionCallback;
 
   explicit StringTraceDataEndpoint(CompletionCallback callback)
       : completion_callback_(callback) {}
 
   void ReceiveTraceFinalContents(
       scoped_ptr<const base::DictionaryValue> metadata,
       const std::string& contents) override {
     std::string tmp = contents;
     scoped_refptr<base::RefCountedString> str =
         base::RefCountedString::TakeString(&tmp);
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(completion_callback_,
-                                       base::Passed(metadata.Pass()), str));
+                                       base::Passed(std::move(metadata)), str));
   }
 
  private:
   ~StringTraceDataEndpoint() override {}
 
   CompletionCallback completion_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(StringTraceDataEndpoint);
 };
 
@@ skipping 269 matching lines @@
 }
 
 void TracingController::TraceDataSink::SetMetadataFilterPredicate(
     const MetadataFilterPredicate& metadata_filter_predicate) {
   metadata_filter_predicate_ = metadata_filter_predicate;
 }
 
 scoped_ptr<const base::DictionaryValue>
     TracingController::TraceDataSink::GetMetadataCopy() const {
   if (metadata_filter_predicate_.is_null())
-    return scoped_ptr<const base::DictionaryValue>(metadata_.DeepCopy()).Pass();
+    return scoped_ptr<const base::DictionaryValue>(metadata_.DeepCopy());
 
   scoped_ptr<base::DictionaryValue> metadata_copy(new base::DictionaryValue);
   for (base::DictionaryValue::Iterator it(metadata_); !it.IsAtEnd();
        it.Advance()) {
     if (metadata_filter_predicate_.Run(it.key()))
       metadata_copy->Set(it.key(), it.value().DeepCopy());
     else
       metadata_copy->SetString(it.key(), "__stripped__");
   }
-  return metadata_copy.Pass();
+  return std::move(metadata_copy);
 }
 
 scoped_refptr<TracingController::TraceDataSink>
 TracingController::CreateStringSink(
     const base::Callback<void(scoped_ptr<const base::DictionaryValue>,
                               base::RefCountedString*)>& callback) {
   return new StringTraceDataSink(new StringTraceDataEndpoint(callback));
 }
 
 scoped_refptr<TracingController::TraceDataSink>
@@ skipping 16 matching lines @@
   return new StringTraceDataEndpoint(callback);
 }
 
 scoped_refptr<TracingController::TraceDataEndpoint>
 TracingController::CreateFileEndpoint(const base::FilePath& file_path,
                                       const base::Closure& callback) {
   return new FileTraceDataEndpoint(file_path, callback);
 }
 
 }  // namespace content