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

chromecast/crash/linux/synchronized_minidump_manager.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 "chromecast/crash/linux/synchronized_minidump_manager.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
+#include <utility>
 
 #include "base/files/dir_reader_posix.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "chromecast/base/path_utils.h"
 #include "chromecast/base/serializers.h"
 #include "chromecast/crash/linux/dump_info.h"
 
@@ skipping 235 matching lines @@
 
   scoped_ptr<base::ListValue> dumps = make_scoped_ptr(new base::ListValue());
 
   // Validate dumps
   for (const std::string& line : lines) {
     if (line.size() == 0)
       continue;
     scoped_ptr<base::Value> dump_info = DeserializeFromJson(line);
     DumpInfo info(dump_info.get());
     RCHECK(info.valid(), -1);
-    dumps->Append(dump_info.Pass());
+    dumps->Append(std::move(dump_info));
   }
 
   scoped_ptr<base::Value> metadata =
       DeserializeJsonFromFile(base::FilePath(metadata_path_));
   RCHECK(ValidateMetadata(metadata.get()), -1);
 
-  dumps_ = dumps.Pass();
-  metadata_ = metadata.Pass();
+  dumps_ = std::move(dumps);
+  metadata_ = std::move(metadata);
   return 0;
 }
 
 int SynchronizedMinidumpManager::WriteFiles(const base::ListValue* dumps,
                                             const base::Value* metadata) {
   DCHECK(dumps);
   DCHECK(metadata);
   std::string lockfile;
 
   for (const base::Value* elem : *dumps) {
@@ skipping 64 matching lines @@
   metadata_.reset();
 }
 
 ScopedVector<DumpInfo> SynchronizedMinidumpManager::GetDumps() {
   ScopedVector<DumpInfo> dumps;
 
   for (const base::Value* elem : *dumps_) {
     dumps.push_back(new DumpInfo(elem));
   }
 
-  return dumps.Pass();
+  return dumps;
 }
 
 int SynchronizedMinidumpManager::SetCurrentDumps(
     const ScopedVector<DumpInfo>& dumps) {
   dumps_->Clear();
 
   for (DumpInfo* dump : dumps)
     dumps_->Append(dump->GetAsValue());
 
   return 0;
@@ skipping 48 matching lines @@
 
     const std::string file_path = dump_path_.Append(reader.name()).value();
     if (file_path != lockfile_path_ && file_path != metadata_path_)
       return true;
   }
 
   return false;
 }
 
 }  // namespace chromecast