Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/httpclient.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 <time.h>
 #include <algorithm>
+#include <memory>
 #include "webrtc/base/asyncsocket.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/diskcache.h"
 #include "webrtc/base/httpclient.h"
 #include "webrtc/base/httpcommon-inl.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/pathutils.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketstream.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 
 //////////////////////////////////////////////////////////////////////
 // Helpers
 //////////////////////////////////////////////////////////////////////
@@ skipping 428 matching lines @@
   CacheLock lock(cache_, id, true);
   if (!lock.IsLocked()) {
     LOG_F(LS_WARNING) << "Couldn't lock cache";
     return false;
   }
 
   if (HE_NONE != WriteCacheHeaders(id)) {
     return false;
   }
 
-  scoped_ptr<StreamInterface> stream(cache_->WriteResource(id, kCacheBody));
+  std::unique_ptr<StreamInterface> stream(
+      cache_->WriteResource(id, kCacheBody));
   if (!stream) {
     LOG_F(LS_ERROR) << "Couldn't open body cache";
     return false;
   }
   lock.Commit();
 
   // Let's secretly replace the response document with Folgers Crystals,
   // er, StreamTap, so that we can mirror the data to our cache.
   StreamInterface* output = response().document.release();
   if (!output) {
     output = new NullStream;
   }
   StreamTap* tap = new StreamTap(output, stream.release());
   response().document.reset(tap);
   return true;
 }
 
 HttpError HttpClient::WriteCacheHeaders(const std::string& id) {
-  scoped_ptr<StreamInterface> stream(cache_->WriteResource(id, kCacheHeader));
+  std::unique_ptr<StreamInterface> stream(
+      cache_->WriteResource(id, kCacheHeader));
   if (!stream) {
     LOG_F(LS_ERROR) << "Couldn't open header cache";
     return HE_CACHE;
   }
 
   if (!HttpWriteCacheHeaders(&transaction_->response, stream.get(), NULL)) {
     LOG_F(LS_ERROR) << "Couldn't write header cache";
     return HE_CACHE;
   }
 
@@ skipping 57 matching lines @@
     LOG_F(LS_WARNING) << "Cache failure, continuing with normal request";
     response().clear(false);
     return false;
   }
 
   SignalHttpClientComplete(this, error);
   return true;
 }
 
 HttpError HttpClient::ReadCacheHeaders(const std::string& id, bool override) {
-  scoped_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheHeader));
+  std::unique_ptr<StreamInterface> stream(
+      cache_->ReadResource(id, kCacheHeader));
   if (!stream) {
     return HE_CACHE;
   }
 
   HttpData::HeaderCombine combine =
     override ? HttpData::HC_REPLACE : HttpData::HC_AUTO;
 
   if (!HttpReadCacheHeaders(stream.get(), &transaction_->response, combine)) {
     LOG_F(LS_ERROR) << "Error reading cache headers";
     return HE_CACHE;
   }
 
   response().scode = HC_OK;
   return HE_NONE;
 }
 
 HttpError HttpClient::ReadCacheBody(const std::string& id) {
   cache_state_ = CS_READING;
 
   HttpError error = HE_NONE;
 
   size_t data_size;
-  scoped_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheBody));
+  std::unique_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheBody));
   if (!stream || !stream->GetAvailable(&data_size)) {
     LOG_F(LS_ERROR) << "Unavailable cache body";
     error = HE_CACHE;
   } else {
     error = OnHeaderAvailable(false, false, data_size);
   }
 
   if ((HE_NONE == error)
       && (HV_HEAD != request().verb)
       && response().document) {
     // Allocate on heap to not explode the stack.
     const int array_size = 1024 * 64;
-    scoped_ptr<char[]> buffer(new char[array_size]);
+    std::unique_ptr<char[]> buffer(new char[array_size]);
     StreamResult result = Flow(stream.get(), buffer.get(), array_size,
                                response().document.get());
     if (SR_SUCCESS != result) {
       error = HE_STREAM;
     }
   }
 
   return error;
 }
 
@@ skipping 210 matching lines @@
                                      const std::string& agent,
                                      HttpTransaction* transaction)
     : ReuseSocketPool(factory ? factory : Thread::Current()->socketserver()),
       HttpClient(agent, NULL, transaction) {
   set_pool(this);
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc