IndexedDB: WrapUnique(new T(args..)) -> MakeUnique<T>(args...)

content/browser/indexed_db/indexed_db_leveldb_coding.cc

 // Copyright (c) 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.
 
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 
 #include <iterator>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 358 matching lines @@
 
 bool DecodeIDBKey(StringPiece* slice, std::unique_ptr<IndexedDBKey>* value) {
   if (slice->empty())
     return false;
 
   unsigned char type = (*slice)[0];
   slice->remove_prefix(1);
 
   switch (type) {
     case kIndexedDBKeyNullTypeByte:
-      *value = base::WrapUnique(new IndexedDBKey());
+      *value = base::MakeUnique<IndexedDBKey>();
       return true;
 
     case kIndexedDBKeyArrayTypeByte: {
       int64_t length = 0;
       if (!DecodeVarInt(slice, &length) || length < 0)
         return false;
       IndexedDBKey::KeyArray array;
       while (length--) {
         std::unique_ptr<IndexedDBKey> key;
         if (!DecodeIDBKey(slice, &key))
           return false;
         array.push_back(*key);
       }
-      *value = base::WrapUnique(new IndexedDBKey(array));
+      *value = base::MakeUnique<IndexedDBKey>(array);
       return true;
     }
     case kIndexedDBKeyBinaryTypeByte: {
       std::string binary;
       if (!DecodeBinary(slice, &binary))
         return false;
-      *value = base::WrapUnique(new IndexedDBKey(binary));
+      *value = base::MakeUnique<IndexedDBKey>(binary);
       return true;
     }
     case kIndexedDBKeyStringTypeByte: {
       base::string16 s;
       if (!DecodeStringWithLength(slice, &s))
         return false;
-      *value = base::WrapUnique(new IndexedDBKey(s));
+      *value = base::MakeUnique<IndexedDBKey>(s);
       return true;
     }
     case kIndexedDBKeyDateTypeByte: {
       double d;
       if (!DecodeDouble(slice, &d))
         return false;
-      *value = base::WrapUnique(new IndexedDBKey(d, WebIDBKeyTypeDate));
+      *value = base::MakeUnique<IndexedDBKey>(d, WebIDBKeyTypeDate);
       return true;
     }
     case kIndexedDBKeyNumberTypeByte: {
       double d;
       if (!DecodeDouble(slice, &d))
         return false;
-      *value = base::WrapUnique(new IndexedDBKey(d, WebIDBKeyTypeNumber));
+      *value = base::MakeUnique<IndexedDBKey>(d, WebIDBKeyTypeNumber);
       return true;
     }
   }
 
   NOTREACHED();
   return false;
 }
 
 bool DecodeDouble(StringPiece* slice, double* value) {
   if (slice->size() < sizeof(*value))
@@ skipping 1465 matching lines @@
 std::unique_ptr<IndexedDBKey> IndexDataKey::primary_key() const {
   std::unique_ptr<IndexedDBKey> key;
   StringPiece slice(encoded_primary_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key;
 }
 
 }  // namespace content