Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/value_store/value_store.h

 // Copyright 2014 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 EXTENSIONS_BROWSER_VALUE_STORE_VALUE_STORE_H_
 #define EXTENSIONS_BROWSER_VALUE_STORE_VALUE_STORE_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "extensions/browser/value_store/value_store_change.h"
 
 // Interface for a storage area for Value objects.
 class ValueStore {
  public:
   // Status codes returned from storage methods.
   enum StatusCode {
     OK,
 
@@ skipping 55 matching lines @@
 
     BackingStoreRestoreStatus restore_status;
 
     // Message associated with the status (error) if there is one.
     std::string message;
   };
 
   // The result of a read operation (Get).
   class ReadResultType {
    public:
-    ReadResultType(scoped_ptr<base::DictionaryValue> settings,
+    ReadResultType(std::unique_ptr<base::DictionaryValue> settings,
                    const Status& status);
     explicit ReadResultType(const Status& status);
     ~ReadResultType();
 
     // Gets the settings read from the storage. Note that this represents
     // the root object. If you request the value for key "foo", that value will
     // be in |settings|.|foo|.
     //
     // Must only be called if there is no error.
     base::DictionaryValue& settings() { return *settings_; }
-    scoped_ptr<base::DictionaryValue> PassSettings() {
+    std::unique_ptr<base::DictionaryValue> PassSettings() {
       return std::move(settings_);
     }
 
     const Status& status() const { return status_; }
 
    private:
-    scoped_ptr<base::DictionaryValue> settings_;
+    std::unique_ptr<base::DictionaryValue> settings_;
     Status status_;
 
     DISALLOW_COPY_AND_ASSIGN(ReadResultType);
   };
-  typedef scoped_ptr<ReadResultType> ReadResult;
+  typedef std::unique_ptr<ReadResultType> ReadResult;
 
   // The result of a write operation (Set/Remove/Clear).
   class WriteResultType {
    public:
-    WriteResultType(scoped_ptr<ValueStoreChangeList> changes,
+    WriteResultType(std::unique_ptr<ValueStoreChangeList> changes,
                     const Status& status);
     explicit WriteResultType(const Status& status);
     ~WriteResultType();
 
     // Gets the list of changes to the settings which resulted from the write.
     // Won't be present if the NO_GENERATE_CHANGES WriteOptions was given.
     // Only call if no error.
     ValueStoreChangeList& changes() { return *changes_; }
-    scoped_ptr<ValueStoreChangeList> PassChanges() {
+    std::unique_ptr<ValueStoreChangeList> PassChanges() {
       return std::move(changes_);
     }
 
     const Status& status() const { return status_; }
 
    private:
-    scoped_ptr<ValueStoreChangeList> changes_;
+    std::unique_ptr<ValueStoreChangeList> changes_;
     Status status_;
 
     DISALLOW_COPY_AND_ASSIGN(WriteResultType);
   };
-  typedef scoped_ptr<WriteResultType> WriteResult;
+  typedef std::unique_ptr<WriteResultType> WriteResult;
 
   // Options for write operations.
   enum WriteOptionsValues {
     // Callers should usually use this.
     DEFAULTS = 0,
 
     // Ignore any quota restrictions.
     IGNORE_QUOTA = 1<<1,
 
     // Don't generate the changes for a WriteResult.
     NO_GENERATE_CHANGES = 1<<2,
   };
   typedef int WriteOptions;
 
   virtual ~ValueStore() {}
 
   // Helpers for making a Read/WriteResult.
   template <typename T>
-  static ReadResult MakeReadResult(scoped_ptr<T> arg, const Status& status) {
+  static ReadResult MakeReadResult(std::unique_ptr<T> arg,
+                                   const Status& status) {
     return ReadResult(new ReadResultType(std::move(arg), status));
   }
   static ReadResult MakeReadResult(const Status& status) {
     return ReadResult(new ReadResultType(status));
   }
 
   template <typename T>
-  static WriteResult MakeWriteResult(scoped_ptr<T> arg, const Status& status) {
+  static WriteResult MakeWriteResult(std::unique_ptr<T> arg,
+                                     const Status& status) {
     return WriteResult(new WriteResultType(std::move(arg), status));
   }
   static WriteResult MakeWriteResult(const Status& status) {
     return WriteResult(new WriteResultType(status));
   }
 
   // Gets the amount of space being used by a single value, in bytes.
   // Note: The GetBytesInUse methods are only used by extension settings at the
   // moment. If these become more generally useful, the
   // SettingsStorageQuotaEnforcer and WeakUnlimitedSettingsStorage classes
@@ skipping 28 matching lines @@
   virtual WriteResult Remove(const std::string& key) = 0;
 
   // Removes multiple keys from the storage.
   virtual WriteResult Remove(const std::vector<std::string>& keys) = 0;
 
   // Clears the storage.
   virtual WriteResult Clear() = 0;
 };
 
 #endif  // EXTENSIONS_BROWSER_VALUE_STORE_VALUE_STORE_H_