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

chrome/renderer/extensions/cast_streaming_native_handler.cc

 // Copyright 2013 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 "chrome/renderer/extensions/cast_streaming_native_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/common/extensions/api/cast_streaming_receiver_session.h"
 #include "chrome/common/extensions/api/cast_streaming_rtp_stream.h"
@@ skipping 788 matching lines @@
         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidAudioParams)));
     return;
   }
 
   scoped_ptr<base::DictionaryValue> options;
   if (args.Length() >= 9) {
     scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
     scoped_ptr<base::Value> options_value(
         converter->FromV8Value(args[8], context()->v8_context()));
     if (!options_value->IsType(base::Value::TYPE_NULL)) {
-      options = base::DictionaryValue::From(options_value.Pass());
+      options = base::DictionaryValue::From(std::move(options_value));
       if (!options) {
         args.GetIsolate()->ThrowException(v8::Exception::TypeError(
             v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
         return;
       }
     }
   }
 
   if (!options) {
     options.reset(new base::DictionaryValue());
   }
 
   v8::CopyablePersistentTraits<v8::Function>::CopyablePersistent error_callback;
   error_callback.Reset(args.GetIsolate(),
                        v8::Local<v8::Function>(args[7].As<v8::Function>()));
 
   session->Start(
       audio_config, video_config, local_endpoint, remote_endpoint,
-      options.Pass(), capture_format,
+      std::move(options), capture_format,
       base::Bind(&CastStreamingNativeHandler::AddTracksToMediaStream,
                  weak_factory_.GetWeakPtr(), url, params),
       base::Bind(&CastStreamingNativeHandler::CallReceiverErrorCallback,
                  weak_factory_.GetWeakPtr(), error_callback));
 }
 
 void CastStreamingNativeHandler::CallReceiverErrorCallback(
     v8::CopyablePersistentTraits<v8::Function>::CopyablePersistent function,
     const std::string& error_message) {
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
   v8::Local<v8::Value> arg = v8::String::NewFromUtf8(isolate,
                                                       error_message.data(),
                                                       v8::String::kNormalString,
                                                       error_message.size());
   context()->CallFunction(
       v8::Local<v8::Function>::New(isolate, function), 1, &arg);
 }
 
 
 void CastStreamingNativeHandler::AddTracksToMediaStream(
     const std::string& url,
     const media::AudioParameters& params,
     scoped_refptr<media::AudioCapturerSource> audio,
     scoped_ptr<media::VideoCapturerSource> video) {
   content::AddAudioTrackToMediaStream(audio, params, true, true, url);
-  content::AddVideoTrackToMediaStream(video.Pass(), true, true, url);
+  content::AddVideoTrackToMediaStream(std::move(video), true, true, url);
 }
 
 }  // namespace extensions