Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/helpers.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/helpers.h"
 
 #include <limits>
+#include <memory>
 
 #if defined(FEATURE_ENABLE_SSL)
 #include "webrtc/base/sslconfig.h"
 #if defined(SSL_USE_OPENSSL)
 #include <openssl/rand.h>
 #else
 #if defined(WEBRTC_WIN)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <ntsecapi.h>
 #endif  // WEBRTC_WIN
 #endif  // else
 #endif  // FEATURE_ENABLED_SSL
 
 #include "webrtc/base/base64.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/timeutils.h"
 
 // Protect against max macro inclusion.
 #undef max
 
 namespace rtc {
 
 // Base class for RNG implementations.
 class RandomGenerator {
  public:
@@ skipping 132 matching lines @@
     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
 
 static const char kHex[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
                               '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
 static const char kUuidDigit17[4] = {'8', '9', 'a', 'b'};
 
 // This round about way of creating a global RNG is to safe-guard against
 // indeterminant static initialization order.
-scoped_ptr<RandomGenerator>& GetGlobalRng() {
-  RTC_DEFINE_STATIC_LOCAL(scoped_ptr<RandomGenerator>, global_rng,
+std::unique_ptr<RandomGenerator>& GetGlobalRng() {
+  RTC_DEFINE_STATIC_LOCAL(std::unique_ptr<RandomGenerator>, global_rng,
                           (new SecureRandomGenerator()));
   return global_rng;
 }
 
 RandomGenerator& Rng() {
   return *GetGlobalRng();
 }
 
 }  // namespace
 
@@ skipping 20 matching lines @@
 std::string CreateRandomString(size_t len) {
   std::string str;
   CreateRandomString(len, &str);
   return str;
 }
 
 bool CreateRandomString(size_t len,
                         const char* table, int table_size,
                         std::string* str) {
   str->clear();
-  scoped_ptr<uint8_t[]> bytes(new uint8_t[len]);
+  std::unique_ptr<uint8_t[]> bytes(new uint8_t[len]);
   if (!Rng().Generate(bytes.get(), len)) {
     LOG(LS_ERROR) << "Failed to generate random string!";
     return false;
   }
   str->reserve(len);
   for (size_t i = 0; i < len; ++i) {
     str->push_back(table[bytes[i] % table_size]);
   }
   return true;
 }
 
 bool CreateRandomString(size_t len, std::string* str) {
   return CreateRandomString(len, kBase64, 64, str);
 }
 
 bool CreateRandomString(size_t len, const std::string& table,
                         std::string* str) {
   return CreateRandomString(len, table.c_str(),
                             static_cast<int>(table.size()), str);
 }
 
 // Version 4 UUID is of the form:
 // xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
 // Where 'x' is a hex digit, and 'y' is 8, 9, a or b.
 std::string CreateRandomUuid() {
   std::string str;
-  scoped_ptr<uint8_t[]> bytes(new uint8_t[31]);
+  std::unique_ptr<uint8_t[]> bytes(new uint8_t[31]);
   if (!Rng().Generate(bytes.get(), 31)) {
     LOG(LS_ERROR) << "Failed to generate random string!";
     return str;
   }
   str.reserve(36);
   for (size_t i = 0; i < 8; ++i) {
     str.push_back(kHex[bytes[i] % 16]);
   }
   str.push_back('-');
   for (size_t i = 8; i < 12; ++i) {
@@ skipping 35 matching lines @@
   } while (id == 0);
   return id;
 }
 
 double CreateRandomDouble() {
   return CreateRandomId() / (std::numeric_limits<uint32_t>::max() +
                              std::numeric_limits<double>::epsilon());
 }
 
 }  // namespace rtc