Convert //sql to use std::unique_ptr

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"
@@ skipping 514 matching lines @@
   sqlite3_file* file = NULL;
   sqlite3_int64 file_size = 0;
   int rc = GetSqlite3FileAndSize(db_, &file, &file_size);
   if (rc != SQLITE_OK)
     return;
 
   // Don't preload more than the file contains.
   if (preload_size > file_size)
     preload_size = file_size;
 
-  scoped_ptr<char[]> buf(new char[page_size]);
+  std::unique_ptr<char[]> buf(new char[page_size]);
   for (sqlite3_int64 pos = 0; pos < preload_size; pos += page_size) {
     rc = file->pMethods->xRead(file, buf.get(), page_size, pos);
 
     // TODO(shess): Consider calling OnSqliteError().
     if (rc != SQLITE_OK)
       return;
   }
 }
 
 // SQLite keeps unused pages associated with a connection in a cache.  It asks
@@ skipping 116 matching lines @@
       db_path.DirName().Append(FILE_PATH_LITERAL("sqlite-diag")));
 
   // Lock against multiple updates to the diagnostics file.  This code should
   // seldom be called in the first place, and when called it should seldom be
   // called for multiple databases, and when called for multiple databases there
   // is _probably_ something systemic wrong with the user's system.  So the lock
   // should never be contended, but when it is the database experience is
   // already bad.
   base::AutoLock lock(g_sqlite_init_lock.Get());
 
-  scoped_ptr<base::Value> root;
+  std::unique_ptr<base::Value> root;
   if (!base::PathExists(breadcrumb_path)) {
-    scoped_ptr<base::DictionaryValue> root_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> root_dict(
+        new base::DictionaryValue());
     root_dict->SetInteger(kVersionKey, kVersion);
 
-    scoped_ptr<base::ListValue> dumps(new base::ListValue);
+    std::unique_ptr<base::ListValue> dumps(new base::ListValue);
     dumps->AppendString(histogram_tag_);
     root_dict->Set(kDiagnosticDumpsKey, std::move(dumps));
 
     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(
+    std::unique_ptr<base::Value> read_root(
         deserializer.Deserialize(nullptr, nullptr));
     if (!read_root.get())
       return false;
-    scoped_ptr<base::DictionaryValue> root_dict =
+    std::unique_ptr<base::DictionaryValue> root_dict =
         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;
@@ skipping 1269 matching lines @@
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql