Convert //sql to use std::unique_ptr

sql/recovery.h

 // 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.
 
 #ifndef SQL_RECOVERY_H_
 #define SQL_RECOVERY_H_
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/macros.h"
 #include "sql/connection.h"
 
 namespace base {
 class FilePath;
 }
 
 namespace sql {
 
 // Recovery module for sql/.  The basic idea is to create a fresh
 // database and populate it with the recovered contents of the
 // original database.  If recovery is successful, the recovered
 // database is backed up over the original database.  If recovery is
 // not successful, the original database is razed.  In either case,
 // the original handle is poisoned so that operations on the stack do
 // not accidentally disrupt the restored data.
 //
 // {
-//   scoped_ptr<sql::Recovery> r =
+//   std::unique_ptr<sql::Recovery> r =
 //       sql::Recovery::Begin(orig_db, orig_db_path);
 //   if (r) {
 //     // Create the schema to recover to.  On failure, clear the
 //     // database.
 //     if (!r.db()->Execute(kCreateSchemaSql)) {
 //       sql::Recovery::Unrecoverable(std::move(r));
 //       return;
 //     }
 //
 //     // Recover data in "mytable".
@@ skipping 34 matching lines @@
   // and attach the existing database to it at "corrupt".  To prevent
   // deadlock, all transactions on |connection| are rolled back.
   //
   // Returns NULL in case of failure, with no cleanup done on the
   // original connection (except for breaking the transactions).  The
   // caller should Raze() or otherwise cleanup as appropriate.
   //
   // TODO(shess): Later versions of SQLite allow extracting the path
   // from the connection.
   // TODO(shess): Allow specifying the connection point?
-  static scoped_ptr<Recovery> Begin(
-      Connection* connection,
-      const base::FilePath& db_path) WARN_UNUSED_RESULT;
+  static std::unique_ptr<Recovery> Begin(Connection* connection,
+                                         const base::FilePath& db_path)
+      WARN_UNUSED_RESULT;
 
   // Mark recovery completed by replicating the recovery database over
   // the original database, then closing the recovery database.  The
   // original database handle is poisoned, causing future calls
   // against it to fail.
   //
   // If Recovered() is not called, the destructor will call
   // Unrecoverable().
   //
   // TODO(shess): At this time, this function can fail while leaving
   // the original database intact.  Figure out which failure cases
   // should go to RazeAndClose() instead.
-  static bool Recovered(scoped_ptr<Recovery> r) WARN_UNUSED_RESULT;
+  static bool Recovered(std::unique_ptr<Recovery> r) WARN_UNUSED_RESULT;
 
   // Indicate that the database is unrecoverable.  The original
   // database is razed, and the handle poisoned.
-  static void Unrecoverable(scoped_ptr<Recovery> r);
+  static void Unrecoverable(std::unique_ptr<Recovery> r);
 
   // When initially developing recovery code, sometimes the possible
   // database states are not well-understood without further
   // diagnostics.  Abandon recovery but do not raze the original
   // database.
   // NOTE(shess): Only call this when adding recovery support.  In the
   // steady state, all databases should progress to recovered or razed.
-  static void Rollback(scoped_ptr<Recovery> r);
+  static void Rollback(std::unique_ptr<Recovery> r);
 
   // Handle to the temporary recovery database.
   sql::Connection* db() { return &recover_db_; }
 
   // Attempt to recover the named table from the corrupt database into
   // the recovery database using a temporary recover virtual table.
   // The virtual table schema is derived from the named table's schema
   // in database [main].  Data is copied using INSERT OR IGNORE, so
   // duplicates are dropped.
   //
@@ skipping 49 matching lines @@
 
   Connection* db_;         // Original database connection.
   Connection recover_db_;  // Recovery connection.
 
   DISALLOW_COPY_AND_ASSIGN(Recovery);
 };
 
 }  // namespace sql
 
 #endif  // SQL_RECOVERY_H_