Global conversion of Pass()→std::move() on Linux

sql/connection.cc

 // Copyright (c) 2012 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 "sql/connection.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 667 matching lines @@
   // already bad.
   base::AutoLock lock(g_sqlite_init_lock.Get());
 
   scoped_ptr<base::Value> root;
   if (!base::PathExists(breadcrumb_path)) {
     scoped_ptr<base::DictionaryValue> root_dict(new base::DictionaryValue());
     root_dict->SetInteger(kVersionKey, kVersion);
 
     scoped_ptr<base::ListValue> dumps(new base::ListValue);
     dumps->AppendString(histogram_tag_);
-    root_dict->Set(kDiagnosticDumpsKey, dumps.Pass());
+    root_dict->Set(kDiagnosticDumpsKey, std::move(dumps));
 
-    root = root_dict.Pass();
+    root = std::move(root_dict);
   } else {
     // Failure to read a valid dictionary implies that something is going wrong
     // on the system.
     JSONFileValueDeserializer deserializer(breadcrumb_path);
     scoped_ptr<base::Value> read_root(
         deserializer.Deserialize(nullptr, nullptr));
     if (!read_root.get())
       return false;
     scoped_ptr<base::DictionaryValue> root_dict =
-        base::DictionaryValue::From(read_root.Pass());
+        base::DictionaryValue::From(std::move(read_root));
     if (!root_dict)
       return false;
 
     // Don't upload if the version is missing or newer.
     int version = 0;
     if (!root_dict->GetInteger(kVersionKey, &version) || version > kVersion)
       return false;
 
     base::ListValue* dumps = nullptr;
     if (!root_dict->GetList(kDiagnosticDumpsKey, &dumps))
       return false;
 
     const size_t size = dumps->GetSize();
     for (size_t i = 0; i < size; ++i) {
       std::string s;
 
       // Don't upload if the value isn't a string, or indicates a prior upload.
       if (!dumps->GetString(i, &s) || s == histogram_tag_)
         return false;
     }
 
     // Record intention to proceed with upload.
     dumps->AppendString(histogram_tag_);
-    root = root_dict.Pass();
+    root = std::move(root_dict);
   }
 
   const base::FilePath breadcrumb_new =
       breadcrumb_path.AddExtension(FILE_PATH_LITERAL("new"));
   base::DeleteFile(breadcrumb_new, false);
 
   // No upload if the breadcrumb file cannot be updated.
   // TODO(shess): Consider ImportantFileWriter::WriteFileAtomically() to land
   // the data on disk.  For now, losing the data is not a big problem, so the
   // sync overhead would probably not be worth it.
@@ skipping 1238 matching lines @@
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql