Change scoped_ptr to std::unique_ptr in //net/quic.
[email protected]
BUG=554298
Review URL: https://codereview.chromium.org/1892973003
Cr-Commit-Position: refs/heads/master@{#387772}
diff --git a/net/quic/bidirectional_stream_quic_impl.cc b/net/quic/bidirectional_stream_quic_impl.cc
index 6e56032..9e4a75e 100644
--- a/net/quic/bidirectional_stream_quic_impl.cc
+++ b/net/quic/bidirectional_stream_quic_impl.cc
@@ -46,7 +46,7 @@
const BidirectionalStreamRequestInfo* request_info,
const BoundNetLog& net_log,
BidirectionalStreamImpl::Delegate* delegate,
- scoped_ptr<base::Timer> /* timer */) {
+ std::unique_ptr<base::Timer> /* timer */) {
DCHECK(!stream_);
if (!session_) {
diff --git a/net/quic/bidirectional_stream_quic_impl.h b/net/quic/bidirectional_stream_quic_impl.h
index b75c3894..2b1f25c 100644
--- a/net/quic/bidirectional_stream_quic_impl.h
+++ b/net/quic/bidirectional_stream_quic_impl.h
@@ -7,8 +7,9 @@
#include <stdint.h>
+#include <memory>
+
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "net/http/bidirectional_stream_impl.h"
#include "net/quic/quic_chromium_client_session.h"
@@ -39,7 +40,7 @@
void Start(const BidirectionalStreamRequestInfo* request_info,
const BoundNetLog& net_log,
BidirectionalStreamImpl::Delegate* delegate,
- scoped_ptr<base::Timer> timer) override;
+ std::unique_ptr<base::Timer> timer) override;
int ReadData(IOBuffer* buffer, int buffer_len) override;
void SendData(IOBuffer* data, int length, bool end_stream) override;
void Cancel() override;
diff --git a/net/quic/bidirectional_stream_quic_impl_unittest.cc b/net/quic/bidirectional_stream_quic_impl_unittest.cc
index 3afdb47..9f90d926 100644
--- a/net/quic/bidirectional_stream_quic_impl_unittest.cc
+++ b/net/quic/bidirectional_stream_quic_impl_unittest.cc
@@ -5,10 +5,12 @@
#include "net/quic/bidirectional_stream_quic_impl.h"
#include <stdint.h>
+
+#include <memory>
#include <vector>
#include "base/callback_helpers.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
@@ -59,11 +61,11 @@
TestDelegateBase(IOBuffer* read_buf, int read_buf_len)
: TestDelegateBase(read_buf,
read_buf_len,
- make_scoped_ptr(new base::Timer(false, false))) {}
+ base::WrapUnique(new base::Timer(false, false))) {}
TestDelegateBase(IOBuffer* read_buf,
int read_buf_len,
- scoped_ptr<base::Timer> timer)
+ std::unique_ptr<base::Timer> timer)
: read_buf_(read_buf),
read_buf_len_(read_buf_len),
timer_(std::move(timer)),
@@ -180,12 +182,12 @@
void DeleteStream() { stream_job_.reset(); }
private:
- scoped_ptr<BidirectionalStreamQuicImpl> stream_job_;
+ std::unique_ptr<BidirectionalStreamQuicImpl> stream_job_;
scoped_refptr<IOBuffer> read_buf_;
int read_buf_len_;
- scoped_ptr<base::Timer> timer_;
+ std::unique_ptr<base::Timer> timer_;
std::string data_received_;
- scoped_ptr<base::RunLoop> loop_;
+ std::unique_ptr<base::RunLoop> loop_;
SpdyHeaderBlock response_headers_;
SpdyHeaderBlock trailers_;
int error_;
@@ -300,11 +302,11 @@
}
// Adds a packet to the list of expected writes.
- void AddWrite(scoped_ptr<QuicReceivedPacket> packet) {
+ void AddWrite(std::unique_ptr<QuicReceivedPacket> packet) {
writes_.push_back(PacketToWrite(SYNCHRONOUS, packet.release()));
}
- void ProcessPacket(scoped_ptr<QuicReceivedPacket> packet) {
+ void ProcessPacket(std::unique_ptr<QuicReceivedPacket> packet) {
connection_->ProcessUdpPacket(self_addr_, peer_addr_, *packet);
}
@@ -323,7 +325,7 @@
socket_data_.reset(new StaticSocketDataProvider(
nullptr, 0, mock_writes_.get(), writes_.size()));
- scoped_ptr<MockUDPClientSocket> socket(new MockUDPClientSocket(
+ std::unique_ptr<MockUDPClientSocket> socket(new MockUDPClientSocket(
socket_data_.get(), net_log().bound().net_log()));
socket->Connect(peer_addr_);
runner_ = new TestTaskRunner(&clock_);
@@ -337,7 +339,7 @@
session_.reset(new QuicChromiumClientSession(
connection_, std::move(socket),
/*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
- &transport_security_state_, make_scoped_ptr((QuicServerInfo*)nullptr),
+ &transport_security_state_, base::WrapUnique((QuicServerInfo*)nullptr),
QuicServerId(kDefaultServerHostName, kDefaultServerPort,
PRIVACY_MODE_DISABLED),
kQuicYieldAfterPacketsRead,
@@ -361,20 +363,20 @@
return maker_.GetResponseHeaders(response_code);
}
- scoped_ptr<QuicReceivedPacket> ConstructDataPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructDataPacket(
QuicPacketNumber packet_number,
bool should_include_version,
bool fin,
QuicStreamOffset offset,
base::StringPiece data) {
- scoped_ptr<QuicReceivedPacket> packet(maker_.MakeDataPacket(
+ std::unique_ptr<QuicReceivedPacket> packet(maker_.MakeDataPacket(
packet_number, stream_id_, should_include_version, fin, offset, data));
DVLOG(2) << "packet(" << packet_number << "): " << std::endl
<< QuicUtils::StringToHexASCIIDump(packet->AsStringPiece());
return packet;
}
- scoped_ptr<QuicReceivedPacket> ConstructRequestHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructRequestHeadersPacket(
QuicPacketNumber packet_number,
bool fin,
RequestPriority request_priority,
@@ -386,7 +388,7 @@
request_headers_, spdy_headers_frame_length);
}
- scoped_ptr<QuicReceivedPacket> ConstructResponseHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructResponseHeadersPacket(
QuicPacketNumber packet_number,
bool fin,
const SpdyHeaderBlock& response_headers,
@@ -397,7 +399,7 @@
spdy_headers_frame_length, offset);
}
- scoped_ptr<QuicReceivedPacket> ConstructResponseTrailersPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructResponseTrailersPacket(
QuicPacketNumber packet_number,
bool fin,
const SpdyHeaderBlock& trailers,
@@ -408,15 +410,15 @@
spdy_headers_frame_length, offset);
}
- scoped_ptr<QuicReceivedPacket> ConstructRstStreamPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructRstStreamPacket(
QuicPacketNumber packet_number) {
return ConstructRstStreamCancelledPacket(packet_number, 0);
}
- scoped_ptr<QuicReceivedPacket> ConstructRstStreamCancelledPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructRstStreamCancelledPacket(
QuicPacketNumber packet_number,
size_t bytes_written) {
- scoped_ptr<QuicReceivedPacket> packet(
+ std::unique_ptr<QuicReceivedPacket> packet(
maker_.MakeRstPacket(packet_number, !kIncludeVersion, stream_id_,
QUIC_STREAM_CANCELLED, bytes_written));
DVLOG(2) << "packet(" << packet_number << "): " << std::endl
@@ -424,7 +426,7 @@
return packet;
}
- scoped_ptr<QuicReceivedPacket> ConstructAckAndRstStreamPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructAckAndRstStreamPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber ack_least_unacked,
@@ -435,7 +437,7 @@
!kIncludeCongestionFeedback);
}
- scoped_ptr<QuicReceivedPacket> ConstructAckAndDataPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructAckAndDataPacket(
QuicPacketNumber packet_number,
bool should_include_version,
QuicPacketNumber largest_received,
@@ -443,7 +445,7 @@
bool fin,
QuicStreamOffset offset,
base::StringPiece data) {
- scoped_ptr<QuicReceivedPacket> packet(maker_.MakeAckAndDataPacket(
+ std::unique_ptr<QuicReceivedPacket> packet(maker_.MakeAckAndDataPacket(
packet_number, should_include_version, stream_id_, largest_received,
least_unacked, fin, offset, data));
DVLOG(2) << "packet(" << packet_number << "): " << std::endl
@@ -451,7 +453,7 @@
return packet;
}
- scoped_ptr<QuicReceivedPacket> ConstructAckPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructAckPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber least_unacked) {
@@ -466,12 +468,12 @@
private:
BoundTestNetLog net_log_;
scoped_refptr<TestTaskRunner> runner_;
- scoped_ptr<MockWrite[]> mock_writes_;
+ std::unique_ptr<MockWrite[]> mock_writes_;
MockClock clock_;
QuicConnection* connection_;
- scoped_ptr<QuicChromiumConnectionHelper> helper_;
+ std::unique_ptr<QuicChromiumConnectionHelper> helper_;
TransportSecurityState transport_security_state_;
- scoped_ptr<QuicChromiumClientSession> session_;
+ std::unique_ptr<QuicChromiumClientSession> session_;
QuicCryptoClientConfig crypto_config_;
HttpRequestHeaders headers_;
HttpResponseInfo response_;
@@ -484,7 +486,7 @@
IPEndPoint peer_addr_;
MockRandom random_generator_;
MockCryptoClientStreamFactory crypto_client_stream_factory_;
- scoped_ptr<StaticSocketDataProvider> socket_data_;
+ std::unique_ptr<StaticSocketDataProvider> socket_data_;
std::vector<PacketToWrite> writes_;
QuicClientPushPromiseIndex push_promise_index_;
};
@@ -509,7 +511,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -600,7 +602,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -677,7 +679,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -754,7 +756,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -793,7 +795,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -850,7 +852,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -900,7 +902,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -954,7 +956,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<TestDelegateBase> delegate(
+ std::unique_ptr<TestDelegateBase> delegate(
new TestDelegateBase(read_buffer.get(), kReadBufferSize));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
delegate->WaitUntilNextCallback(); // OnHeadersSent
@@ -1003,7 +1005,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
+ std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
read_buffer.get(), kReadBufferSize,
DeleteStreamDelegate::ON_HEADERS_RECEIVED, true));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
@@ -1046,7 +1048,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<DeleteStreamDelegate> delegate(
+ std::unique_ptr<DeleteStreamDelegate> delegate(
new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
DeleteStreamDelegate::ON_DATA_READ, true));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
@@ -1098,7 +1100,7 @@
request.priority = DEFAULT_PRIORITY;
scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
- scoped_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
+ std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
read_buffer.get(), kReadBufferSize,
DeleteStreamDelegate::ON_TRAILERS_RECEIVED, true));
delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
diff --git a/net/quic/congestion_control/hybrid_slow_start_test.cc b/net/quic/congestion_control/hybrid_slow_start_test.cc
index d3d0fda..0e8c934 100644
--- a/net/quic/congestion_control/hybrid_slow_start_test.cc
+++ b/net/quic/congestion_control/hybrid_slow_start_test.cc
@@ -4,8 +4,9 @@
#include "net/quic/congestion_control/hybrid_slow_start.h"
+#include <memory>
+
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
@@ -19,7 +20,7 @@
void SetUp() override { slow_start_.reset(new HybridSlowStart()); }
const QuicTime::Delta one_ms_;
const QuicTime::Delta rtt_;
- scoped_ptr<HybridSlowStart> slow_start_;
+ std::unique_ptr<HybridSlowStart> slow_start_;
};
TEST_F(HybridSlowStartTest, Simple) {
diff --git a/net/quic/congestion_control/pacing_sender.h b/net/quic/congestion_control/pacing_sender.h
index 3aeedd29..5c48320 100644
--- a/net/quic/congestion_control/pacing_sender.h
+++ b/net/quic/congestion_control/pacing_sender.h
@@ -14,9 +14,9 @@
#include <stdint.h>
#include <map>
+#include <memory>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/congestion_control/send_algorithm_interface.h"
#include "net/quic/quic_bandwidth.h"
#include "net/quic/quic_config.h"
@@ -68,7 +68,7 @@
// End implementation of SendAlgorithmInterface.
private:
- scoped_ptr<SendAlgorithmInterface> sender_; // Underlying sender.
+ std::unique_ptr<SendAlgorithmInterface> sender_; // Underlying sender.
// The estimated system alarm granularity.
const QuicTime::Delta alarm_granularity_;
// Configured maximum size of the burst coming out of quiescence. The burst
diff --git a/net/quic/congestion_control/pacing_sender_test.cc b/net/quic/congestion_control/pacing_sender_test.cc
index fbbcfec..e6dfcb6 100644
--- a/net/quic/congestion_control/pacing_sender_test.cc
+++ b/net/quic/congestion_control/pacing_sender_test.cc
@@ -4,8 +4,9 @@
#include "net/quic/congestion_control/pacing_sender.h"
+#include <memory>
+
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/quic_protocol.h"
#include "net/quic/test_tools/mock_clock.h"
#include "net/quic/test_tools/quic_test_utils.h"
@@ -100,7 +101,7 @@
MockClock clock_;
QuicPacketNumber packet_number_;
StrictMock<MockSendAlgorithm>* mock_sender_;
- scoped_ptr<PacingSender> pacing_sender_;
+ std::unique_ptr<PacingSender> pacing_sender_;
};
TEST_F(PacingSenderTest, NoSend) {
diff --git a/net/quic/congestion_control/tcp_cubic_sender_bytes_test.cc b/net/quic/congestion_control/tcp_cubic_sender_bytes_test.cc
index eaacb5b..1bedee8 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_bytes_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_bytes_test.cc
@@ -5,9 +5,9 @@
#include "net/quic/congestion_control/tcp_cubic_sender_bytes.h"
#include <algorithm>
+#include <memory>
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/congestion_control/rtt_stats.h"
#include "net/quic/crypto/crypto_protocol.h"
#include "net/quic/proto/cached_network_parameters.pb.h"
@@ -123,7 +123,7 @@
const QuicTime::Delta one_ms_;
MockClock clock_;
- scoped_ptr<TcpCubicSenderBytesPeer> sender_;
+ std::unique_ptr<TcpCubicSenderBytesPeer> sender_;
QuicPacketNumber packet_number_;
QuicPacketNumber acked_packet_number_;
QuicByteCount bytes_in_flight_;
diff --git a/net/quic/congestion_control/tcp_cubic_sender_packets_test.cc b/net/quic/congestion_control/tcp_cubic_sender_packets_test.cc
index f4a4227..18359b1 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_packets_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_packets_test.cc
@@ -5,9 +5,9 @@
#include "net/quic/congestion_control/tcp_cubic_sender_packets.h"
#include <algorithm>
+#include <memory>
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/congestion_control/rtt_stats.h"
#include "net/quic/crypto/crypto_protocol.h"
#include "net/quic/proto/cached_network_parameters.pb.h"
@@ -132,7 +132,7 @@
const QuicTime::Delta one_ms_;
MockClock clock_;
- scoped_ptr<TcpCubicSenderPacketsPeer> sender_;
+ std::unique_ptr<TcpCubicSenderPacketsPeer> sender_;
QuicPacketNumber packet_number_;
QuicPacketNumber acked_packet_number_;
QuicByteCount bytes_in_flight_;
diff --git a/net/quic/crypto/aead_base_decrypter_nss.cc b/net/quic/crypto/aead_base_decrypter_nss.cc
index 4787860..30865e4 100644
--- a/net/quic/crypto/aead_base_decrypter_nss.cc
+++ b/net/quic/crypto/aead_base_decrypter_nss.cc
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "net/quic/crypto/aead_base_decrypter.h"
-
#include <pk11pub.h>
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
#include "crypto/scoped_nss_types.h"
+#include "net/quic/crypto/aead_base_decrypter.h"
#include "net/quic/quic_flags.h"
#include "net/quic/quic_utils.h"
diff --git a/net/quic/crypto/aead_base_decrypter_openssl.cc b/net/quic/crypto/aead_base_decrypter_openssl.cc
index cb91a69..aa62a45f 100644
--- a/net/quic/crypto/aead_base_decrypter_openssl.cc
+++ b/net/quic/crypto/aead_base_decrypter_openssl.cc
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "net/quic/crypto/aead_base_decrypter.h"
-
#include <openssl/err.h>
#include <openssl/evp.h>
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
+#include "net/quic/crypto/aead_base_decrypter.h"
#include "net/quic/quic_flags.h"
#include "net/quic/quic_utils.h"
diff --git a/net/quic/crypto/aead_base_encrypter_nss.cc b/net/quic/crypto/aead_base_encrypter_nss.cc
index 4fb1349d..cfb6e79e 100644
--- a/net/quic/crypto/aead_base_encrypter_nss.cc
+++ b/net/quic/crypto/aead_base_encrypter_nss.cc
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "net/quic/crypto/aead_base_encrypter.h"
-
#include <pk11pub.h>
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
#include "crypto/scoped_nss_types.h"
+#include "net/quic/crypto/aead_base_encrypter.h"
#include "net/quic/quic_flags.h"
#include "net/quic/quic_utils.h"
diff --git a/net/quic/crypto/aead_base_encrypter_openssl.cc b/net/quic/crypto/aead_base_encrypter_openssl.cc
index 92856a6c0..108df58 100644
--- a/net/quic/crypto/aead_base_encrypter_openssl.cc
+++ b/net/quic/crypto/aead_base_encrypter_openssl.cc
@@ -2,13 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "net/quic/crypto/aead_base_encrypter.h"
-
#include <openssl/err.h>
#include <openssl/evp.h>
#include <string.h>
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
+#include "net/quic/crypto/aead_base_encrypter.h"
#include "net/quic/quic_flags.h"
#include "net/quic/quic_utils.h"
diff --git a/net/quic/crypto/aes_128_gcm_12_decrypter_test.cc b/net/quic/crypto/aes_128_gcm_12_decrypter_test.cc
index d0e5304..f045afa0 100644
--- a/net/quic/crypto/aes_128_gcm_12_decrypter_test.cc
+++ b/net/quic/crypto/aes_128_gcm_12_decrypter_test.cc
@@ -209,7 +209,7 @@
path_id = static_cast<QuicPathId>(
packet_number >> 8 * (sizeof(packet_number) - sizeof(path_id)));
packet_number &= UINT64_C(0x00FFFFFFFFFFFFFF);
- scoped_ptr<char[]> output(new char[ciphertext.length()]);
+ std::unique_ptr<char[]> output(new char[ciphertext.length()]);
size_t output_length = 0;
const bool success = decrypter->DecryptPacket(
path_id, packet_number, associated_data, ciphertext, output.get(),
@@ -266,7 +266,7 @@
Aes128Gcm12Decrypter decrypter;
ASSERT_TRUE(decrypter.SetKey(key));
- scoped_ptr<QuicData> decrypted(DecryptWithNonce(
+ std::unique_ptr<QuicData> decrypted(DecryptWithNonce(
&decrypter, iv,
// This deliberately tests that the decrypter can handle an AAD that
// is set to nullptr, as opposed to a zero-length, non-nullptr
diff --git a/net/quic/crypto/aes_128_gcm_12_encrypter_test.cc b/net/quic/crypto/aes_128_gcm_12_encrypter_test.cc
index 82539a2..7b61962 100644
--- a/net/quic/crypto/aes_128_gcm_12_encrypter_test.cc
+++ b/net/quic/crypto/aes_128_gcm_12_encrypter_test.cc
@@ -158,7 +158,7 @@
StringPiece associated_data,
StringPiece plaintext) {
size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
- scoped_ptr<char[]> ciphertext(new char[ciphertext_size]);
+ std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]);
if (!encrypter->Encrypt(nonce, associated_data, plaintext,
reinterpret_cast<unsigned char*>(ciphertext.get()))) {
@@ -199,7 +199,7 @@
Aes128Gcm12Encrypter encrypter;
ASSERT_TRUE(encrypter.SetKey(key));
- scoped_ptr<QuicData> encrypted(EncryptWithNonce(
+ std::unique_ptr<QuicData> encrypted(EncryptWithNonce(
&encrypter, iv,
// This deliberately tests that the encrypter can handle an AAD that
// is set to nullptr, as opposed to a zero-length, non-nullptr
diff --git a/net/quic/crypto/cert_compressor.cc b/net/quic/crypto/cert_compressor.cc
index 5851bd9..0f1075d 100644
--- a/net/quic/crypto/cert_compressor.cc
+++ b/net/quic/crypto/cert_compressor.cc
@@ -4,8 +4,9 @@
#include "net/quic/crypto/cert_compressor.h"
+#include <memory>
+
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/quic_utils.h"
#include "third_party/zlib/zlib.h"
@@ -564,7 +565,7 @@
}
DCHECK_EQ(entries.size(), out_certs->size());
- scoped_ptr<uint8_t[]> uncompressed_data;
+ std::unique_ptr<uint8_t[]> uncompressed_data;
StringPiece uncompressed;
if (!in.empty()) {
diff --git a/net/quic/crypto/cert_compressor_test.cc b/net/quic/crypto/cert_compressor_test.cc
index baefae5..251313b 100644
--- a/net/quic/crypto/cert_compressor_test.cc
+++ b/net/quic/crypto/cert_compressor_test.cc
@@ -47,7 +47,7 @@
vector<string> chain;
chain.push_back("testcert");
static const uint64_t set_hash = 42;
- scoped_ptr<CommonCertSets> common_sets(
+ std::unique_ptr<CommonCertSets> common_sets(
CryptoTestUtils::MockCommonCertSets(chain[0], set_hash, 1));
const string compressed = CertCompressor::CompressChain(
chain,
@@ -127,7 +127,7 @@
without_a_common_cert_set.size()),
cached_certs, nullptr, &chain));
- scoped_ptr<CommonCertSets> common_sets(
+ std::unique_ptr<CommonCertSets> common_sets(
CryptoTestUtils::MockCommonCertSets("foo", 42, 1));
/* incorrect hash and index */
diff --git a/net/quic/crypto/chacha20_poly1305_rfc7539_decrypter_test.cc b/net/quic/crypto/chacha20_poly1305_rfc7539_decrypter_test.cc
index 3acc1fc..ca80202 100644
--- a/net/quic/crypto/chacha20_poly1305_rfc7539_decrypter_test.cc
+++ b/net/quic/crypto/chacha20_poly1305_rfc7539_decrypter_test.cc
@@ -123,7 +123,7 @@
path_id = static_cast<QuicPathId>(
packet_number >> 8 * (sizeof(packet_number) - sizeof(path_id)));
packet_number &= UINT64_C(0x00FFFFFFFFFFFFFF);
- scoped_ptr<char[]> output(new char[ciphertext.length()]);
+ std::unique_ptr<char[]> output(new char[ciphertext.length()]);
size_t output_length = 0;
const bool success = decrypter->DecryptPacket(
path_id, packet_number, associated_data, ciphertext, output.get(),
@@ -161,7 +161,7 @@
ChaCha20Poly1305Rfc7539Decrypter decrypter;
ASSERT_TRUE(decrypter.SetKey(key));
- scoped_ptr<QuicData> decrypted(DecryptWithNonce(
+ std::unique_ptr<QuicData> decrypted(DecryptWithNonce(
&decrypter, fixed + iv,
// This deliberately tests that the decrypter can handle an AAD that
// is set to nullptr, as opposed to a zero-length, non-nullptr pointer.
diff --git a/net/quic/crypto/chacha20_poly1305_rfc7539_encrypter_test.cc b/net/quic/crypto/chacha20_poly1305_rfc7539_encrypter_test.cc
index 9e246f9..b9d9d47 100644
--- a/net/quic/crypto/chacha20_poly1305_rfc7539_encrypter_test.cc
+++ b/net/quic/crypto/chacha20_poly1305_rfc7539_encrypter_test.cc
@@ -72,7 +72,7 @@
StringPiece associated_data,
StringPiece plaintext) {
size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
- scoped_ptr<char[]> ciphertext(new char[ciphertext_size]);
+ std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]);
if (!encrypter->Encrypt(nonce, associated_data, plaintext,
reinterpret_cast<unsigned char*>(ciphertext.get()))) {
@@ -137,7 +137,7 @@
ChaCha20Poly1305Rfc7539Encrypter encrypter;
ASSERT_TRUE(encrypter.SetKey(key));
- scoped_ptr<QuicData> encrypted(EncryptWithNonce(
+ std::unique_ptr<QuicData> encrypted(EncryptWithNonce(
&encrypter, fixed + iv,
// This deliberately tests that the encrypter can handle an AAD that
// is set to nullptr, as opposed to a zero-length, non-nullptr pointer.
diff --git a/net/quic/crypto/channel_id.h b/net/quic/crypto/channel_id.h
index 0ec1d4dd..cb2632f 100644
--- a/net/quic/crypto/channel_id.h
+++ b/net/quic/crypto/channel_id.h
@@ -5,10 +5,10 @@
#ifndef NET_QUIC_CRYPTO_CHANNEL_ID_H_
#define NET_QUIC_CRYPTO_CHANNEL_ID_H_
+#include <memory>
#include <string>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/quic/quic_types.h"
@@ -40,7 +40,7 @@
// asynchonous GetChannelIDKey operation. If |*channel_id_key| is not nullptr
// then the channel ID lookup is successful. |Run| may take ownership of
// |*channel_id_key| by calling |release| on it.
- virtual void Run(scoped_ptr<ChannelIDKey>* channel_id_key) = 0;
+ virtual void Run(std::unique_ptr<ChannelIDKey>* channel_id_key) = 0;
};
// ChannelIDSource is an abstract interface by which a QUIC client can obtain
@@ -59,7 +59,7 @@
// |callback|.
virtual QuicAsyncStatus GetChannelIDKey(
const std::string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* callback) = 0;
};
diff --git a/net/quic/crypto/channel_id_chromium.cc b/net/quic/crypto/channel_id_chromium.cc
index 1aec7e7..ac71fb023 100644
--- a/net/quic/crypto/channel_id_chromium.cc
+++ b/net/quic/crypto/channel_id_chromium.cc
@@ -19,14 +19,14 @@
namespace net {
ChannelIDKeyChromium::ChannelIDKeyChromium(
- scoped_ptr<crypto::ECPrivateKey> ec_private_key)
+ std::unique_ptr<crypto::ECPrivateKey> ec_private_key)
: ec_private_key_(std::move(ec_private_key)) {}
ChannelIDKeyChromium::~ChannelIDKeyChromium() {}
bool ChannelIDKeyChromium::Sign(base::StringPiece signed_data,
std::string* out_signature) const {
- scoped_ptr<crypto::ECSignatureCreator> sig_creator(
+ std::unique_ptr<crypto::ECSignatureCreator> sig_creator(
crypto::ECSignatureCreator::Create(ec_private_key_.get()));
if (!sig_creator) {
return false;
@@ -69,7 +69,7 @@
// Starts the channel ID lookup. If |QUIC_PENDING| is returned, then
// |callback| will be invoked asynchronously when the operation completes.
QuicAsyncStatus GetChannelIDKey(const std::string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* callback);
private:
@@ -89,15 +89,15 @@
ChannelIDService* const channel_id_service_;
- scoped_ptr<crypto::ECPrivateKey> channel_id_crypto_key_;
+ std::unique_ptr<crypto::ECPrivateKey> channel_id_crypto_key_;
ChannelIDService::Request channel_id_request_;
// |hostname| specifies the hostname for which we need a channel ID.
std::string hostname_;
- scoped_ptr<ChannelIDSourceCallback> callback_;
+ std::unique_ptr<ChannelIDSourceCallback> callback_;
- scoped_ptr<ChannelIDKey> channel_id_key_;
+ std::unique_ptr<ChannelIDKey> channel_id_key_;
State next_state_;
@@ -112,7 +112,7 @@
QuicAsyncStatus ChannelIDSourceChromium::Job::GetChannelIDKey(
const std::string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* callback) {
DCHECK(channel_id_key);
DCHECK(callback);
@@ -166,7 +166,7 @@
void ChannelIDSourceChromium::Job::OnIOComplete(int result) {
int rv = DoLoop(result);
if (rv != ERR_IO_PENDING) {
- scoped_ptr<ChannelIDSourceCallback> callback(callback_.release());
+ std::unique_ptr<ChannelIDSourceCallback> callback(callback_.release());
callback->Run(&channel_id_key_);
// Will delete |this|.
channel_id_source_->OnJobComplete(this);
@@ -206,9 +206,9 @@
QuicAsyncStatus ChannelIDSourceChromium::GetChannelIDKey(
const std::string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* callback) {
- scoped_ptr<Job> job(new Job(this, channel_id_service_));
+ std::unique_ptr<Job> job(new Job(this, channel_id_service_));
QuicAsyncStatus status =
job->GetChannelIDKey(hostname, channel_id_key, callback);
if (status == QUIC_PENDING) {
diff --git a/net/quic/crypto/channel_id_chromium.h b/net/quic/crypto/channel_id_chromium.h
index 7dfb9b5..c93000a 100644
--- a/net/quic/crypto/channel_id_chromium.h
+++ b/net/quic/crypto/channel_id_chromium.h
@@ -21,7 +21,7 @@
class NET_EXPORT_PRIVATE ChannelIDKeyChromium : public ChannelIDKey {
public:
explicit ChannelIDKeyChromium(
- scoped_ptr<crypto::ECPrivateKey> ec_private_key);
+ std::unique_ptr<crypto::ECPrivateKey> ec_private_key);
~ChannelIDKeyChromium() override;
// ChannelIDKey interface
@@ -30,7 +30,7 @@
std::string SerializeKey() const override;
private:
- scoped_ptr<crypto::ECPrivateKey> ec_private_key_;
+ std::unique_ptr<crypto::ECPrivateKey> ec_private_key_;
};
// ChannelIDSourceChromium implements the QUIC ChannelIDSource interface.
@@ -41,7 +41,7 @@
// ChannelIDSource interface
QuicAsyncStatus GetChannelIDKey(const std::string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* callback) override;
private:
diff --git a/net/quic/crypto/channel_id_test.cc b/net/quic/crypto/channel_id_test.cc
index 8aa2f74..1453071b 100644
--- a/net/quic/crypto/channel_id_test.cc
+++ b/net/quic/crypto/channel_id_test.cc
@@ -234,12 +234,12 @@
}
TEST(ChannelIDTest, SignAndVerify) {
- scoped_ptr<ChannelIDSource> source(
+ std::unique_ptr<ChannelIDSource> source(
CryptoTestUtils::ChannelIDSourceForTesting());
const string signed_data = "signed data";
const string hostname = "foo.example.com";
- scoped_ptr<ChannelIDKey> channel_id_key;
+ std::unique_ptr<ChannelIDKey> channel_id_key;
QuicAsyncStatus status =
source->GetChannelIDKey(hostname, &channel_id_key, nullptr);
ASSERT_EQ(QUIC_SUCCESS, status);
@@ -253,13 +253,13 @@
EXPECT_FALSE(ChannelIDVerifier::Verify("a" + key, signed_data, signature));
EXPECT_FALSE(ChannelIDVerifier::Verify(key, "a" + signed_data, signature));
- scoped_ptr<char[]> bad_key(new char[key.size()]);
+ std::unique_ptr<char[]> bad_key(new char[key.size()]);
memcpy(bad_key.get(), key.data(), key.size());
bad_key[1] ^= 0x80;
EXPECT_FALSE(ChannelIDVerifier::Verify(string(bad_key.get(), key.size()),
signed_data, signature));
- scoped_ptr<char[]> bad_signature(new char[signature.size()]);
+ std::unique_ptr<char[]> bad_signature(new char[signature.size()]);
memcpy(bad_signature.get(), signature.data(), signature.size());
bad_signature[1] ^= 0x80;
EXPECT_FALSE(ChannelIDVerifier::Verify(
diff --git a/net/quic/crypto/crypto_framer.cc b/net/quic/crypto/crypto_framer.cc
index 2d80980..8e04aef 100644
--- a/net/quic/crypto/crypto_framer.cc
+++ b/net/quic/crypto/crypto_framer.cc
@@ -37,7 +37,7 @@
CryptoHandshakeMessage* release() { return out_.release(); }
private:
- scoped_ptr<CryptoHandshakeMessage> out_;
+ std::unique_ptr<CryptoHandshakeMessage> out_;
bool error_;
};
@@ -105,7 +105,7 @@
return nullptr;
}
- scoped_ptr<char[]> buffer(new char[len]);
+ std::unique_ptr<char[]> buffer(new char[len]);
QuicDataWriter writer(len, buffer.get());
if (!writer.WriteUInt32(message.tag())) {
DCHECK(false) << "Failed to write message tag.";
diff --git a/net/quic/crypto/crypto_framer_test.cc b/net/quic/crypto/crypto_framer_test.cc
index f60380f..e39c21f 100644
--- a/net/quic/crypto/crypto_framer_test.cc
+++ b/net/quic/crypto/crypto_framer_test.cc
@@ -5,10 +5,10 @@
#include "net/quic/crypto/crypto_framer.h"
#include <map>
+#include <memory>
#include <vector>
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/crypto/crypto_handshake.h"
#include "net/quic/crypto/crypto_protocol.h"
#include "net/quic/quic_protocol.h"
@@ -86,7 +86,7 @@
};
CryptoFramer framer;
- scoped_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
+ std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
ASSERT_TRUE(data.get() != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
data->length(), AsChars(packet),
@@ -121,7 +121,7 @@
};
CryptoFramer framer;
- scoped_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
+ std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
ASSERT_TRUE(data.get() != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -148,7 +148,7 @@
};
CryptoFramer framer;
- scoped_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
+ std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
ASSERT_TRUE(data.get() != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -164,7 +164,7 @@
}
CryptoFramer framer;
- scoped_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
+ std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
EXPECT_TRUE(data.get() == nullptr);
}
@@ -198,7 +198,7 @@
};
CryptoFramer framer;
- scoped_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
+ std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
ASSERT_TRUE(data.get() != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -234,7 +234,7 @@
};
CryptoFramer framer;
- scoped_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
+ std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
ASSERT_TRUE(data.get() != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
diff --git a/net/quic/crypto/crypto_handshake.h b/net/quic/crypto/crypto_handshake.h
index d9d51e3..dd958c2e 100644
--- a/net/quic/crypto/crypto_handshake.h
+++ b/net/quic/crypto/crypto_handshake.h
@@ -7,11 +7,11 @@
#include <stdint.h>
+#include <memory>
#include <string>
#include <vector>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
#include "net/quic/quic_protocol.h"
@@ -94,8 +94,8 @@
struct NET_EXPORT_PRIVATE CrypterPair {
CrypterPair();
~CrypterPair();
- scoped_ptr<QuicEncrypter> encrypter;
- scoped_ptr<QuicDecrypter> decrypter;
+ std::unique_ptr<QuicEncrypter> encrypter;
+ std::unique_ptr<QuicDecrypter> decrypter;
};
// Parameters negotiated by the crypto handshake.
@@ -130,7 +130,7 @@
std::vector<std::string> cached_certs;
// client_key_exchange is used by clients to store the ephemeral KeyExchange
// for the connection.
- scoped_ptr<KeyExchange> client_key_exchange;
+ std::unique_ptr<KeyExchange> client_key_exchange;
// channel_id is set by servers to a ChannelID key when the client correctly
// proves possession of the corresponding private key. It consists of 32
// bytes of x coordinate, followed by 32 bytes of y coordinate. Both values
diff --git a/net/quic/crypto/crypto_handshake_message.cc b/net/quic/crypto/crypto_handshake_message.cc
index 5e4e48d..05ffa67 100644
--- a/net/quic/crypto/crypto_handshake_message.cc
+++ b/net/quic/crypto/crypto_handshake_message.cc
@@ -304,7 +304,7 @@
case kSCFG:
// nested messages.
if (!it->second.empty()) {
- scoped_ptr<CryptoHandshakeMessage> msg(
+ std::unique_ptr<CryptoHandshakeMessage> msg(
CryptoFramer::ParseMessage(it->second));
if (msg.get()) {
ret += "\n";
diff --git a/net/quic/crypto/crypto_handshake_message.h b/net/quic/crypto/crypto_handshake_message.h
index a3778cb7..86052f2 100644
--- a/net/quic/crypto/crypto_handshake_message.h
+++ b/net/quic/crypto/crypto_handshake_message.h
@@ -8,10 +8,10 @@
#include <stddef.h>
#include <stdint.h>
+#include <memory>
#include <string>
#include <vector>
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/quic/quic_protocol.h"
@@ -132,7 +132,7 @@
// The serialized form of the handshake message. This member is constructed
// lasily.
- mutable scoped_ptr<QuicData> serialized_;
+ mutable std::unique_ptr<QuicData> serialized_;
};
} // namespace net
diff --git a/net/quic/crypto/crypto_secret_boxer.cc b/net/quic/crypto/crypto_secret_boxer.cc
index 08a4317..347333f 100644
--- a/net/quic/crypto/crypto_secret_boxer.cc
+++ b/net/quic/crypto/crypto_secret_boxer.cc
@@ -4,8 +4,9 @@
#include "net/quic/crypto/crypto_secret_boxer.h"
+#include <memory>
+
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/crypto/aes_128_gcm_12_decrypter.h"
#include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
#include "net/quic/crypto/crypto_protocol.h"
@@ -55,7 +56,7 @@
}
string CryptoSecretBoxer::Box(QuicRandom* rand, StringPiece plaintext) const {
- scoped_ptr<Aes128Gcm12Encrypter> encrypter(new Aes128Gcm12Encrypter());
+ std::unique_ptr<Aes128Gcm12Encrypter> encrypter(new Aes128Gcm12Encrypter());
{
base::AutoLock l(lock_);
DCHECK_EQ(kKeySize, keys_[0].size());
@@ -99,7 +100,7 @@
memcpy(&packet_number, nonce.data() + nonce_prefix.size(),
sizeof(packet_number));
- scoped_ptr<Aes128Gcm12Decrypter> decrypter(new Aes128Gcm12Decrypter());
+ std::unique_ptr<Aes128Gcm12Decrypter> decrypter(new Aes128Gcm12Decrypter());
char plaintext[kMaxPacketSize];
size_t plaintext_length = 0;
bool ok = false;
diff --git a/net/quic/crypto/crypto_secret_boxer_test.cc b/net/quic/crypto/crypto_secret_boxer_test.cc
index c73c581c..6d5cad1 100644
--- a/net/quic/crypto/crypto_secret_boxer_test.cc
+++ b/net/quic/crypto/crypto_secret_boxer_test.cc
@@ -4,7 +4,8 @@
#include "net/quic/crypto/crypto_secret_boxer.h"
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
#include "net/quic/crypto/quic_random.h"
#include "testing/gtest/include/gtest/gtest.h"
diff --git a/net/quic/crypto/crypto_server_test.cc b/net/quic/crypto/crypto_server_test.cc
index d2fd4c5..5dfcf51 100644
--- a/net/quic/crypto/crypto_server_test.cc
+++ b/net/quic/crypto/crypto_server_test.cc
@@ -43,7 +43,7 @@
void Run(bool ok,
const std::string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) override {
+ std::unique_ptr<ProofVerifyDetails>* details) override {
// Do nothing
}
};
@@ -151,10 +151,10 @@
old_config_options.id = kOldConfigId;
delete config_.AddDefaultConfig(rand_, &clock_, old_config_options);
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
- scoped_ptr<QuicServerConfigProtobuf> primary_config(
+ std::unique_ptr<QuicServerConfigProtobuf> primary_config(
config_.GenerateConfig(rand_, &clock_, config_options_));
primary_config->set_primary_time(clock_.WallNow().ToUNIXSeconds());
- scoped_ptr<CryptoHandshakeMessage> msg(
+ std::unique_ptr<CryptoHandshakeMessage> msg(
config_.AddConfig(primary_config.get(), clock_.WallNow()));
StringPiece orbit;
@@ -380,7 +380,7 @@
IPAddress server_ip;
string sig;
string cert_sct;
- scoped_ptr<ProofSource> proof_source(
+ std::unique_ptr<ProofSource> proof_source(
CryptoTestUtils::ProofSourceForTesting());
if (!proof_source->GetProof(server_ip, "", "", client_version_, "", false,
&chain, &sig, &cert_sct) ||
@@ -415,7 +415,7 @@
// These strings contain hex escaped values from the server suitable for using
// when constructing client hello messages.
string nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
- scoped_ptr<CryptoHandshakeMessage> server_config_;
+ std::unique_ptr<CryptoHandshakeMessage> server_config_;
};
// Run all CryptoServerTest with both values of
@@ -849,7 +849,8 @@
EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
EXPECT_TRUE(out_.GetStringPiece(kSCFG, &scfg_str));
- scoped_ptr<CryptoHandshakeMessage> scfg(CryptoFramer::ParseMessage(scfg_str));
+ std::unique_ptr<CryptoHandshakeMessage> scfg(
+ CryptoFramer::ParseMessage(scfg_str));
StringPiece scid;
EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
EXPECT_NE(scid, kOldConfigId);
@@ -863,11 +864,11 @@
common_cert_sets, &certs));
// Check that the proof in the REJ message is valid.
- scoped_ptr<ProofVerifier> proof_verifier(
+ std::unique_ptr<ProofVerifier> proof_verifier(
CryptoTestUtils::ProofVerifierForTesting());
- scoped_ptr<ProofVerifyContext> verify_context(
+ std::unique_ptr<ProofVerifyContext> verify_context(
CryptoTestUtils::ProofVerifyContextForTesting());
- scoped_ptr<ProofVerifyDetails> details;
+ std::unique_ptr<ProofVerifyDetails> details;
string error_details;
DummyProofVerifierCallback callback;
string chlo_hash;
@@ -981,9 +982,9 @@
CryptoTestUtils::ProofSourceForTesting());
QuicCryptoServerConfig b(QuicCryptoServerConfig::TESTING, &rand_b,
CryptoTestUtils::ProofSourceForTesting());
- scoped_ptr<CryptoHandshakeMessage> scfg_a(
+ std::unique_ptr<CryptoHandshakeMessage> scfg_a(
a.AddDefaultConfig(&rand_a, &clock, options));
- scoped_ptr<CryptoHandshakeMessage> scfg_b(
+ std::unique_ptr<CryptoHandshakeMessage> scfg_b(
b.AddDefaultConfig(&rand_b, &clock, options));
ASSERT_EQ(scfg_a->DebugString(), scfg_b->DebugString());
@@ -1002,9 +1003,9 @@
rand_b.ChangeValue();
QuicCryptoServerConfig b(QuicCryptoServerConfig::TESTING, &rand_b,
CryptoTestUtils::ProofSourceForTesting());
- scoped_ptr<CryptoHandshakeMessage> scfg_a(
+ std::unique_ptr<CryptoHandshakeMessage> scfg_a(
a.AddDefaultConfig(&rand_a, &clock, options));
- scoped_ptr<CryptoHandshakeMessage> scfg_b(
+ std::unique_ptr<CryptoHandshakeMessage> scfg_b(
b.AddDefaultConfig(&rand_b, &clock, options));
StringPiece scid_a, scid_b;
@@ -1021,7 +1022,7 @@
QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a,
CryptoTestUtils::ProofSourceForTesting());
- scoped_ptr<CryptoHandshakeMessage> scfg(
+ std::unique_ptr<CryptoHandshakeMessage> scfg(
a.AddDefaultConfig(&rand_a, &clock, options));
StringPiece scid;
@@ -1033,7 +1034,7 @@
scfg->MarkDirty();
const QuicData& serialized(scfg->GetSerialized());
- scoped_ptr<crypto::SecureHash> hash(
+ std::unique_ptr<crypto::SecureHash> hash(
crypto::SecureHash::Create(crypto::SecureHash::SHA256));
hash->Update(serialized.data(), serialized.length());
uint8_t digest[16];
diff --git a/net/quic/crypto/crypto_utils.cc b/net/quic/crypto/crypto_utils.cc
index 2b22acd..a052520 100644
--- a/net/quic/crypto/crypto_utils.cc
+++ b/net/quic/crypto/crypto_utils.cc
@@ -279,7 +279,7 @@
void CryptoUtils::HashHandshakeMessage(const CryptoHandshakeMessage& message,
string* output) {
const QuicData& serialized = message.GetSerialized();
- scoped_ptr<crypto::SecureHash> hash(
+ std::unique_ptr<crypto::SecureHash> hash(
crypto::SecureHash::Create(crypto::SecureHash::SHA256));
hash->Update(serialized.data(), serialized.length());
uint8_t digest[32];
diff --git a/net/quic/crypto/curve25519_key_exchange_test.cc b/net/quic/crypto/curve25519_key_exchange_test.cc
index 93ef630..6c87d243 100644
--- a/net/quic/crypto/curve25519_key_exchange_test.cc
+++ b/net/quic/crypto/curve25519_key_exchange_test.cc
@@ -4,7 +4,8 @@
#include "net/quic/crypto/curve25519_key_exchange.h"
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
#include "base/strings/string_piece.h"
#include "net/quic/crypto/quic_random.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -24,9 +25,10 @@
const string alice_key(Curve25519KeyExchange::NewPrivateKey(rand));
const string bob_key(Curve25519KeyExchange::NewPrivateKey(rand));
- scoped_ptr<Curve25519KeyExchange> alice(
+ std::unique_ptr<Curve25519KeyExchange> alice(
Curve25519KeyExchange::New(alice_key));
- scoped_ptr<Curve25519KeyExchange> bob(Curve25519KeyExchange::New(bob_key));
+ std::unique_ptr<Curve25519KeyExchange> bob(
+ Curve25519KeyExchange::New(bob_key));
const StringPiece alice_public(alice->public_value());
const StringPiece bob_public(bob->public_value());
diff --git a/net/quic/crypto/local_strike_register_client_test.cc b/net/quic/crypto/local_strike_register_client_test.cc
index 74bf095..d72dcb1 100644
--- a/net/quic/crypto/local_strike_register_client_test.cc
+++ b/net/quic/crypto/local_strike_register_client_test.cc
@@ -7,7 +7,6 @@
#include <memory>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "base/sys_byteorder.h"
#include "net/quic/crypto/crypto_protocol.h"
@@ -66,7 +65,7 @@
StrikeRegister::NO_STARTUP_PERIOD_NEEDED));
}
- scoped_ptr<LocalStrikeRegisterClient> strike_register_;
+ std::unique_ptr<LocalStrikeRegisterClient> strike_register_;
};
TEST_F(LocalStrikeRegisterClientTest, CheckOrbit) {
diff --git a/net/quic/crypto/p256_key_exchange.h b/net/quic/crypto/p256_key_exchange.h
index 197adfe5..fcdc19dd 100644
--- a/net/quic/crypto/p256_key_exchange.h
+++ b/net/quic/crypto/p256_key_exchange.h
@@ -7,10 +7,10 @@
#include <stdint.h>
+#include <memory>
#include <string>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/quic/crypto/key_exchange.h"
@@ -70,7 +70,7 @@
// |public_key| consists of |kUncompressedP256PointBytes| bytes.
P256KeyExchange(crypto::ECPrivateKey* key_pair, const uint8_t* public_key);
- scoped_ptr<crypto::ECPrivateKey> key_pair_;
+ std::unique_ptr<crypto::ECPrivateKey> key_pair_;
#endif
// The public key stored as an uncompressed P-256 point.
uint8_t public_key_[kUncompressedP256PointBytes];
diff --git a/net/quic/crypto/p256_key_exchange_nss.cc b/net/quic/crypto/p256_key_exchange_nss.cc
index c5529ab..8c28e53 100644
--- a/net/quic/crypto/p256_key_exchange_nss.cc
+++ b/net/quic/crypto/p256_key_exchange_nss.cc
@@ -62,7 +62,7 @@
StringPiece public_piece(key);
- scoped_ptr<crypto::ECPrivateKey> key_pair(
+ std::unique_ptr<crypto::ECPrivateKey> key_pair(
crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
kExportPassword,
// TODO(thaidn): fix this interface to avoid copying secrets.
@@ -106,7 +106,8 @@
// static
string P256KeyExchange::NewPrivateKey() {
- scoped_ptr<crypto::ECPrivateKey> key_pair(crypto::ECPrivateKey::Create());
+ std::unique_ptr<crypto::ECPrivateKey> key_pair(
+ crypto::ECPrivateKey::Create());
if (!key_pair.get()) {
DVLOG(1) << "Can't generate new key pair.";
diff --git a/net/quic/crypto/p256_key_exchange_openssl.cc b/net/quic/crypto/p256_key_exchange_openssl.cc
index 9703a2e9..47e68ba 100644
--- a/net/quic/crypto/p256_key_exchange_openssl.cc
+++ b/net/quic/crypto/p256_key_exchange_openssl.cc
@@ -62,7 +62,7 @@
DVLOG(1) << "Can't convert private key to string";
return string();
}
- scoped_ptr<uint8_t[]> private_key(new uint8_t[key_len]);
+ std::unique_ptr<uint8_t[]> private_key(new uint8_t[key_len]);
uint8_t* keyp = private_key.get();
if (!i2d_ECPrivateKey(key.get(), &keyp)) {
DVLOG(1) << "Can't convert private key to string.";
diff --git a/net/quic/crypto/p256_key_exchange_test.cc b/net/quic/crypto/p256_key_exchange_test.cc
index 4052c2da..079eb40d 100644
--- a/net/quic/crypto/p256_key_exchange_test.cc
+++ b/net/quic/crypto/p256_key_exchange_test.cc
@@ -23,8 +23,8 @@
ASSERT_FALSE(bob_private.empty());
ASSERT_NE(alice_private, bob_private);
- scoped_ptr<P256KeyExchange> alice(P256KeyExchange::New(alice_private));
- scoped_ptr<P256KeyExchange> bob(P256KeyExchange::New(bob_private));
+ std::unique_ptr<P256KeyExchange> alice(P256KeyExchange::New(alice_private));
+ std::unique_ptr<P256KeyExchange> bob(P256KeyExchange::New(bob_private));
ASSERT_TRUE(alice.get() != nullptr);
ASSERT_TRUE(bob.get() != nullptr);
diff --git a/net/quic/crypto/proof_source_chromium.h b/net/quic/crypto/proof_source_chromium.h
index 70b8ea1..f84746e 100644
--- a/net/quic/crypto/proof_source_chromium.h
+++ b/net/quic/crypto/proof_source_chromium.h
@@ -44,7 +44,7 @@
std::string* out_leaf_cert_sct) override;
private:
- scoped_ptr<crypto::RSAPrivateKey> private_key_;
+ std::unique_ptr<crypto::RSAPrivateKey> private_key_;
scoped_refptr<ProofSource::Chain> chain_;
std::string signed_certificate_timestamp_;
diff --git a/net/quic/crypto/proof_test.cc b/net/quic/crypto/proof_test.cc
index 8042b2b..67af4127 100644
--- a/net/quic/crypto/proof_test.cc
+++ b/net/quic/crypto/proof_test.cc
@@ -39,7 +39,7 @@
void Run(bool ok,
const string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) override {
+ std::unique_ptr<ProofVerifyDetails>* details) override {
*ok_ = ok;
*error_details_ = error_details;
@@ -63,11 +63,11 @@
const vector<string>& certs,
const string& proof,
bool expected_ok) {
- scoped_ptr<ProofVerifyDetails> details;
+ std::unique_ptr<ProofVerifyDetails> details;
TestCompletionCallback comp_callback;
bool ok;
string error_details;
- scoped_ptr<ProofVerifyContext> verify_context(
+ std::unique_ptr<ProofVerifyContext> verify_context(
CryptoTestUtils::ProofVerifyContextForTesting());
TestProofVerifierCallback* callback =
new TestProofVerifierCallback(&comp_callback, &ok, &error_details);
@@ -117,8 +117,8 @@
// TODO(rtenneti): Enable testing of ProofVerifier. See http://crbug.com/514468.
TEST_P(ProofTest, DISABLED_Verify) {
- scoped_ptr<ProofSource> source(CryptoTestUtils::ProofSourceForTesting());
- scoped_ptr<ProofVerifier> verifier(
+ std::unique_ptr<ProofSource> source(CryptoTestUtils::ProofSourceForTesting());
+ std::unique_ptr<ProofVerifier> verifier(
CryptoTestUtils::ProofVerifierForTesting());
const string server_config = "server config bytes";
@@ -279,7 +279,7 @@
0xad, 0x42, 0xe5, 0x55,
};
- scoped_ptr<ProofVerifier> verifier(
+ std::unique_ptr<ProofVerifier> verifier(
CryptoTestUtils::RealProofVerifierForTesting());
const string server_config = "server config bytes";
@@ -370,7 +370,7 @@
0x1f, 0xce, 0x92, 0x05, 0xca, 0x29, 0xfe, 0xd2, 0x8f, 0xd9, 0x31,
};
- scoped_ptr<ProofVerifier> verifier(
+ std::unique_ptr<ProofVerifier> verifier(
CryptoTestUtils::RealProofVerifierForTesting());
const string server_config = "server config bytes";
diff --git a/net/quic/crypto/proof_verifier.h b/net/quic/crypto/proof_verifier.h
index be6f9e7..fc520aa 100644
--- a/net/quic/crypto/proof_verifier.h
+++ b/net/quic/crypto/proof_verifier.h
@@ -5,10 +5,10 @@
#ifndef NET_QUIC_CRYPTO_PROOF_VERIFIER_H_
#define NET_QUIC_CRYPTO_PROOF_VERIFIER_H_
+#include <memory>
#include <string>
#include <vector>
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
#include "net/quic/quic_protocol.h"
#include "net/quic/quic_types.h"
@@ -48,7 +48,7 @@
// calling |release| on it.
virtual void Run(bool ok,
const std::string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) = 0;
+ std::unique_ptr<ProofVerifyDetails>* details) = 0;
};
// A ProofVerifier checks the signature on a server config, and the certificate
@@ -74,18 +74,19 @@
//
// The signature uses SHA-256 as the hash function and PSS padding in the
// case of RSA.
- virtual QuicAsyncStatus VerifyProof(const std::string& hostname,
- const uint16_t port,
- const std::string& server_config,
- QuicVersion quic_version,
- base::StringPiece chlo_hash,
- const std::vector<std::string>& certs,
- const std::string& cert_sct,
- const std::string& signature,
- const ProofVerifyContext* context,
- std::string* error_details,
- scoped_ptr<ProofVerifyDetails>* details,
- ProofVerifierCallback* callback) = 0;
+ virtual QuicAsyncStatus VerifyProof(
+ const std::string& hostname,
+ const uint16_t port,
+ const std::string& server_config,
+ QuicVersion quic_version,
+ base::StringPiece chlo_hash,
+ const std::vector<std::string>& certs,
+ const std::string& cert_sct,
+ const std::string& signature,
+ const ProofVerifyContext* context,
+ std::string* error_details,
+ std::unique_ptr<ProofVerifyDetails>* details,
+ ProofVerifierCallback* callback) = 0;
};
} // namespace net
diff --git a/net/quic/crypto/proof_verifier_chromium.cc b/net/quic/crypto/proof_verifier_chromium.cc
index 044c694b..93d9721 100644
--- a/net/quic/crypto/proof_verifier_chromium.cc
+++ b/net/quic/crypto/proof_verifier_chromium.cc
@@ -62,17 +62,18 @@
// Starts the proof verification. If |QUIC_PENDING| is returned, then
// |callback| will be invoked asynchronously when the verification completes.
- QuicAsyncStatus VerifyProof(const std::string& hostname,
- const uint16_t port,
- const std::string& server_config,
- QuicVersion quic_version,
- base::StringPiece chlo_hash,
- const std::vector<std::string>& certs,
- const std::string& cert_sct,
- const std::string& signature,
- std::string* error_details,
- scoped_ptr<ProofVerifyDetails>* verify_details,
- ProofVerifierCallback* callback);
+ QuicAsyncStatus VerifyProof(
+ const std::string& hostname,
+ const uint16_t port,
+ const std::string& server_config,
+ QuicVersion quic_version,
+ base::StringPiece chlo_hash,
+ const std::vector<std::string>& certs,
+ const std::string& cert_sct,
+ const std::string& signature,
+ std::string* error_details,
+ std::unique_ptr<ProofVerifyDetails>* verify_details,
+ ProofVerifierCallback* callback);
private:
enum State {
@@ -97,7 +98,7 @@
// The underlying verifier used for verifying certificates.
CertVerifier* verifier_;
- scoped_ptr<CertVerifier::Request> cert_verifier_request_;
+ std::unique_ptr<CertVerifier::Request> cert_verifier_request_;
CTPolicyEnforcer* policy_enforcer_;
@@ -110,8 +111,8 @@
// |port| specifies the target port for the connection.
uint16_t port_;
- scoped_ptr<ProofVerifierCallback> callback_;
- scoped_ptr<ProofVerifyDetailsChromium> verify_details_;
+ std::unique_ptr<ProofVerifierCallback> callback_;
+ std::unique_ptr<ProofVerifyDetailsChromium> verify_details_;
std::string error_details_;
// X509Certificate from a chain of DER encoded certificates.
@@ -169,7 +170,7 @@
const std::string& cert_sct,
const string& signature,
std::string* error_details,
- scoped_ptr<ProofVerifyDetails>* verify_details,
+ std::unique_ptr<ProofVerifyDetails>* verify_details,
ProofVerifierCallback* callback) {
DCHECK(error_details);
DCHECK(verify_details);
@@ -271,9 +272,10 @@
void ProofVerifierChromium::Job::OnIOComplete(int result) {
int rv = DoLoop(result);
if (rv != ERR_IO_PENDING) {
- scoped_ptr<ProofVerifierCallback> callback(std::move(callback_));
+ std::unique_ptr<ProofVerifierCallback> callback(std::move(callback_));
// Callback expects ProofVerifyDetails not ProofVerifyDetailsChromium.
- scoped_ptr<ProofVerifyDetails> verify_details(std::move(verify_details_));
+ std::unique_ptr<ProofVerifyDetails> verify_details(
+ std::move(verify_details_));
callback->Run(rv == OK, error_details_, &verify_details);
// Will delete |this|.
proof_verifier_->OnJobComplete(this);
@@ -448,7 +450,7 @@
const std::string& signature,
const ProofVerifyContext* verify_context,
std::string* error_details,
- scoped_ptr<ProofVerifyDetails>* verify_details,
+ std::unique_ptr<ProofVerifyDetails>* verify_details,
ProofVerifierCallback* callback) {
if (!verify_context) {
*error_details = "Missing context";
@@ -456,7 +458,7 @@
}
const ProofVerifyContextChromium* chromium_context =
reinterpret_cast<const ProofVerifyContextChromium*>(verify_context);
- scoped_ptr<Job> job(
+ std::unique_ptr<Job> job(
new Job(this, cert_verifier_, ct_policy_enforcer_,
transport_security_state_, cert_transparency_verifier_,
chromium_context->cert_verify_flags, chromium_context->net_log));
diff --git a/net/quic/crypto/proof_verifier_chromium.h b/net/quic/crypto/proof_verifier_chromium.h
index eef604d2f..be50650 100644
--- a/net/quic/crypto/proof_verifier_chromium.h
+++ b/net/quic/crypto/proof_verifier_chromium.h
@@ -5,13 +5,13 @@
#ifndef NET_QUIC_CRYPTO_PROOF_VERIFIER_CHROMIUM_H_
#define NET_QUIC_CRYPTO_PROOF_VERIFIER_CHROMIUM_H_
+#include <memory>
#include <set>
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
#include "net/cert/cert_verify_result.h"
#include "net/cert/ct_verify_result.h"
@@ -65,18 +65,19 @@
~ProofVerifierChromium() override;
// ProofVerifier interface
- QuicAsyncStatus VerifyProof(const std::string& hostname,
- const uint16_t port,
- const std::string& server_config,
- QuicVersion quic_version,
- base::StringPiece chlo_hash,
- const std::vector<std::string>& certs,
- const std::string& cert_sct,
- const std::string& signature,
- const ProofVerifyContext* verify_context,
- std::string* error_details,
- scoped_ptr<ProofVerifyDetails>* verify_details,
- ProofVerifierCallback* callback) override;
+ QuicAsyncStatus VerifyProof(
+ const std::string& hostname,
+ const uint16_t port,
+ const std::string& server_config,
+ QuicVersion quic_version,
+ base::StringPiece chlo_hash,
+ const std::vector<std::string>& certs,
+ const std::string& cert_sct,
+ const std::string& signature,
+ const ProofVerifyContext* verify_context,
+ std::string* error_details,
+ std::unique_ptr<ProofVerifyDetails>* verify_details,
+ ProofVerifierCallback* callback) override;
private:
class Job;
diff --git a/net/quic/crypto/proof_verifier_chromium_test.cc b/net/quic/crypto/proof_verifier_chromium_test.cc
index bc2d27f..9b90b67 100644
--- a/net/quic/crypto/proof_verifier_chromium_test.cc
+++ b/net/quic/crypto/proof_verifier_chromium_test.cc
@@ -4,8 +4,9 @@
#include "net/quic/crypto/proof_verifier_chromium.h"
+#include <memory>
+
#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_errors.h"
#include "net/base/test_data_directory.h"
#include "net/cert/cert_status_flags.h"
@@ -44,7 +45,7 @@
CRLSet* crl_set,
CertVerifyResult* verify_result,
const CompletionCallback& callback,
- scoped_ptr<CertVerifier::Request>* out_req,
+ std::unique_ptr<CertVerifier::Request>* out_req,
const BoundNetLog& net_log) override {
ADD_FAILURE() << "CertVerifier::Verify() should not be called";
return ERR_FAILED;
@@ -95,7 +96,7 @@
void Run(bool ok,
const std::string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) override {
+ std::unique_ptr<ProofVerifyDetails>* details) override {
// Do nothing
}
};
@@ -205,10 +206,10 @@
}
protected:
- scoped_ptr<MultiLogCTVerifier> ct_verifier_;
+ std::unique_ptr<MultiLogCTVerifier> ct_verifier_;
std::vector<scoped_refptr<const CTLogVerifier>> log_verifiers_;
- scoped_ptr<ProofVerifyContext> verify_context_;
- scoped_ptr<ProofVerifyDetails> details_;
+ std::unique_ptr<ProofVerifyContext> verify_context_;
+ std::unique_ptr<ProofVerifyDetails> details_;
std::string error_details_;
std::vector<std::string> certs_;
};
@@ -220,7 +221,7 @@
ProofVerifierChromium proof_verifier(&dummy_verifier, nullptr, nullptr,
ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_, "",
@@ -238,7 +239,7 @@
ProofVerifierChromium proof_verifier(&cert_verifier, nullptr, nullptr,
ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_,
@@ -257,7 +258,7 @@
ProofVerifierChromium proof_verifier(&cert_verifier, nullptr, nullptr,
ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_,
@@ -274,7 +275,7 @@
ProofVerifierChromium proof_verifier(&cert_verifier, nullptr, nullptr,
ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_, "",
@@ -299,7 +300,7 @@
ProofVerifierChromium proof_verifier(&dummy_verifier, nullptr, nullptr,
ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_, "",
@@ -332,7 +333,7 @@
ProofVerifierChromium proof_verifier(&dummy_verifier, &policy_enforcer,
nullptr, ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_, "",
@@ -365,7 +366,7 @@
ProofVerifierChromium proof_verifier(&dummy_verifier, &policy_enforcer,
nullptr, ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_, "",
@@ -399,7 +400,7 @@
ProofVerifierChromium proof_verifier(&dummy_verifier, &policy_enforcer,
nullptr, ct_verifier_.get());
- scoped_ptr<DummyProofVerifierCallback> callback(
+ std::unique_ptr<DummyProofVerifierCallback> callback(
new DummyProofVerifierCallback);
QuicAsyncStatus status = proof_verifier.VerifyProof(
kTestHostname, kTestPort, kTestConfig, QUIC_VERSION_25, "", certs_, "",
diff --git a/net/quic/crypto/quic_crypto_client_config.cc b/net/quic/crypto/quic_crypto_client_config.cc
index a6906a7..e6dad8c1 100644
--- a/net/quic/crypto/quic_crypto_client_config.cc
+++ b/net/quic/crypto/quic_crypto_client_config.cc
@@ -147,7 +147,7 @@
// Even if the new server config matches the existing one, we still wish to
// reject it if it has expired.
- scoped_ptr<CryptoHandshakeMessage> new_scfg_storage;
+ std::unique_ptr<CryptoHandshakeMessage> new_scfg_storage;
const CryptoHandshakeMessage* new_scfg;
if (!matches_existing) {
@@ -659,7 +659,7 @@
const QuicData& cetv_plaintext = cetv.GetSerialized();
const size_t encrypted_len =
crypters.encrypter->GetCiphertextSize(cetv_plaintext.length());
- scoped_ptr<char[]> output(new char[encrypted_len]);
+ std::unique_ptr<char[]> output(new char[encrypted_len]);
size_t output_size = 0;
if (!crypters.encrypter->EncryptPacket(
kDefaultPathId /* path id */, 0 /* packet number */,
diff --git a/net/quic/crypto/quic_crypto_client_config.h b/net/quic/crypto/quic_crypto_client_config.h
index a0c3536..9401a93c 100644
--- a/net/quic/crypto/quic_crypto_client_config.h
+++ b/net/quic/crypto/quic_crypto_client_config.h
@@ -8,12 +8,12 @@
#include <stdint.h>
#include <map>
+#include <memory>
#include <queue>
#include <string>
#include <vector>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/quic/crypto/crypto_handshake.h"
@@ -180,10 +180,10 @@
// server_config_valid_ to false.
uint64_t generation_counter_;
- scoped_ptr<ProofVerifyDetails> proof_verify_details_;
+ std::unique_ptr<ProofVerifyDetails> proof_verify_details_;
// scfg contains the cached, parsed value of |server_config|.
- mutable scoped_ptr<CryptoHandshakeMessage> scfg_;
+ mutable std::unique_ptr<CryptoHandshakeMessage> scfg_;
// TODO(jokulik): Consider using a hash-set as extra book-keeping to ensure
// that no connection-id is added twice. Also, consider keeping the server
@@ -366,8 +366,8 @@
// ".googlevideo.com") of canonical hostnames.
std::vector<std::string> canonical_suffixes_;
- scoped_ptr<ProofVerifier> proof_verifier_;
- scoped_ptr<ChannelIDSource> channel_id_source_;
+ std::unique_ptr<ProofVerifier> proof_verifier_;
+ std::unique_ptr<ChannelIDSource> channel_id_source_;
// True if ECDSA should be disabled.
bool disable_ecdsa_;
diff --git a/net/quic/crypto/quic_crypto_server_config.cc b/net/quic/crypto/quic_crypto_server_config.cc
index 2d0c664..b107df3 100644
--- a/net/quic/crypto/quic_crypto_server_config.cc
+++ b/net/quic/crypto/quic_crypto_server_config.cc
@@ -235,7 +235,7 @@
server_nonce_entropy->RandBytes(server_nonce_orbit_,
sizeof(server_nonce_orbit_));
const size_t key_size = server_nonce_boxer_.GetKeySize();
- scoped_ptr<uint8_t[]> key_bytes(new uint8_t[key_size]);
+ std::unique_ptr<uint8_t[]> key_bytes(new uint8_t[key_size]);
server_nonce_entropy->RandBytes(key_bytes.get(), key_size);
server_nonce_boxer_.SetKeys(
@@ -255,7 +255,7 @@
const string curve25519_private_key =
Curve25519KeyExchange::NewPrivateKey(rand);
- scoped_ptr<Curve25519KeyExchange> curve25519(
+ std::unique_ptr<Curve25519KeyExchange> curve25519(
Curve25519KeyExchange::New(curve25519_private_key));
StringPiece curve25519_public_value = curve25519->public_value();
@@ -274,7 +274,8 @@
string p256_private_key;
if (options.p256) {
p256_private_key = P256KeyExchange::NewPrivateKey();
- scoped_ptr<P256KeyExchange> p256(P256KeyExchange::New(p256_private_key));
+ std::unique_ptr<P256KeyExchange> p256(
+ P256KeyExchange::New(p256_private_key));
StringPiece p256_public_value = p256->public_value();
DCHECK_LT(p256_public_value.size(), (1U << 24));
@@ -332,9 +333,9 @@
if (options.id.empty()) {
// We need to ensure that the SCID changes whenever the server config does
// thus we make it a hash of the rest of the server config.
- scoped_ptr<QuicData> serialized(
+ std::unique_ptr<QuicData> serialized(
CryptoFramer::ConstructHandshakeMessage(msg));
- scoped_ptr<SecureHash> hash(SecureHash::Create(SecureHash::SHA256));
+ std::unique_ptr<SecureHash> hash(SecureHash::Create(SecureHash::SHA256));
hash->Update(serialized->data(), serialized->length());
char scid_bytes[16];
@@ -347,9 +348,11 @@
// everything but itself and so extra tags should be added prior to the
// preceeding if block.
- scoped_ptr<QuicData> serialized(CryptoFramer::ConstructHandshakeMessage(msg));
+ std::unique_ptr<QuicData> serialized(
+ CryptoFramer::ConstructHandshakeMessage(msg));
- scoped_ptr<QuicServerConfigProtobuf> config(new QuicServerConfigProtobuf);
+ std::unique_ptr<QuicServerConfigProtobuf> config(
+ new QuicServerConfigProtobuf);
config->set_config(serialized->AsStringPiece());
QuicServerConfigProtobuf::PrivateKey* curve25519_key = config->add_key();
curve25519_key->set_tag(kC255);
@@ -367,7 +370,7 @@
CryptoHandshakeMessage* QuicCryptoServerConfig::AddConfig(
QuicServerConfigProtobuf* protobuf,
const QuicWallTime now) {
- scoped_ptr<CryptoHandshakeMessage> msg(
+ std::unique_ptr<CryptoHandshakeMessage> msg(
CryptoFramer::ParseMessage(protobuf->config()));
if (!msg.get()) {
@@ -403,7 +406,7 @@
QuicRandom* rand,
const QuicClock* clock,
const ConfigOptions& options) {
- scoped_ptr<QuicServerConfigProtobuf> config(
+ std::unique_ptr<QuicServerConfigProtobuf> config(
GenerateConfig(rand, clock, options));
return AddConfig(config.get(), clock->WallNow());
}
@@ -691,7 +694,7 @@
}
if (!info.sni.empty()) {
- scoped_ptr<char[]> sni_tmp(new char[info.sni.length() + 1]);
+ std::unique_ptr<char[]> sni_tmp(new char[info.sni.length() + 1]);
memcpy(sni_tmp.get(), info.sni.data(), info.sni.length());
sni_tmp[info.sni.length()] = 0;
params->sni = CryptoUtils::NormalizeHostname(sni_tmp.get());
@@ -752,7 +755,7 @@
*error_details = "CETV decryption failure";
return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
}
- scoped_ptr<CryptoHandshakeMessage> cetv(
+ std::unique_ptr<CryptoHandshakeMessage> cetv(
CryptoFramer::ParseMessage(StringPiece(plaintext, plaintext_length)));
if (!cetv.get()) {
*error_details = "CETV parse error";
@@ -793,7 +796,7 @@
key_exchange, rand, clock->ApproximateNow(), public_value,
&forward_secure_public_value);
} else {
- scoped_ptr<KeyExchange> forward_secure_key_exchange(
+ std::unique_ptr<KeyExchange> forward_secure_key_exchange(
key_exchange->NewKeyPair(rand));
forward_secure_public_value =
forward_secure_key_exchange->public_value().as_string();
@@ -1317,7 +1320,7 @@
scoped_refptr<QuicCryptoServerConfig::Config>
QuicCryptoServerConfig::ParseConfigProtobuf(
QuicServerConfigProtobuf* protobuf) {
- scoped_ptr<CryptoHandshakeMessage> msg(
+ std::unique_ptr<CryptoHandshakeMessage> msg(
CryptoFramer::ParseMessage(protobuf->config()));
if (msg->tag() != kSCFG) {
@@ -1453,7 +1456,7 @@
return nullptr;
}
- scoped_ptr<KeyExchange> ka;
+ std::unique_ptr<KeyExchange> ka;
switch (tag) {
case kC255:
ka.reset(Curve25519KeyExchange::New(private_key));
diff --git a/net/quic/crypto/quic_crypto_server_config.h b/net/quic/crypto/quic_crypto_server_config.h
index 33f088d..a457ae2 100644
--- a/net/quic/crypto/quic_crypto_server_config.h
+++ b/net/quic/crypto/quic_crypto_server_config.h
@@ -9,12 +9,12 @@
#include <stdint.h>
#include <map>
+#include <memory>
#include <string>
#include <vector>
#include "base/macros.h"
#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "base/synchronization/lock.h"
#include "net/base/ip_address.h"
@@ -432,7 +432,7 @@
// Holds the override source_address_token_boxer instance if the
// Config is not using the default source address token boxer
// instance provided by QuicCryptoServerConfig.
- scoped_ptr<CryptoSecretBoxer> source_address_token_boxer_storage;
+ std::unique_ptr<CryptoSecretBoxer> source_address_token_boxer_storage;
private:
friend class base::RefCounted<Config>;
@@ -599,13 +599,13 @@
// active config will be promoted to primary.
mutable QuicWallTime next_config_promotion_time_;
// Callback to invoke when the primary config changes.
- scoped_ptr<PrimaryConfigChangedCallback> primary_config_changed_cb_;
+ std::unique_ptr<PrimaryConfigChangedCallback> primary_config_changed_cb_;
// Protects access to the pointer held by strike_register_client_.
mutable base::Lock strike_register_client_lock_;
// strike_register_ contains a data structure that keeps track of previously
// observed client nonces in order to prevent replay attacks.
- mutable scoped_ptr<StrikeRegisterClient> strike_register_client_;
+ mutable std::unique_ptr<StrikeRegisterClient> strike_register_client_;
// Default source_address_token_boxer_ used to protect the
// source-address tokens that are given to clients. Individual
@@ -625,15 +625,15 @@
// server_nonce_strike_register_ contains a data structure that keeps track of
// previously observed server nonces from this server, in order to prevent
// replay attacks.
- mutable scoped_ptr<StrikeRegister> server_nonce_strike_register_;
+ mutable std::unique_ptr<StrikeRegister> server_nonce_strike_register_;
// proof_source_ contains an object that can provide certificate chains and
// signatures.
- scoped_ptr<ProofSource> proof_source_;
+ std::unique_ptr<ProofSource> proof_source_;
// ephemeral_key_source_ contains an object that caches ephemeral keys for a
// short period of time.
- scoped_ptr<EphemeralKeySource> ephemeral_key_source_;
+ std::unique_ptr<EphemeralKeySource> ephemeral_key_source_;
// These fields store configuration values. See the comments for their
// respective setter functions.
diff --git a/net/quic/crypto/quic_crypto_server_config_test.cc b/net/quic/crypto/quic_crypto_server_config_test.cc
index 270cd9a2..38c6d2ef 100644
--- a/net/quic/crypto/quic_crypto_server_config_test.cc
+++ b/net/quic/crypto/quic_crypto_server_config_test.cc
@@ -234,7 +234,7 @@
CryptoTestUtils::ProofSourceForTesting());
MockClock clock;
- scoped_ptr<CryptoHandshakeMessage> message(server.AddDefaultConfig(
+ std::unique_ptr<CryptoHandshakeMessage> message(server.AddDefaultConfig(
rand, &clock, QuicCryptoServerConfig::ConfigOptions()));
// The default configuration should have AES-GCM and at least one ChaCha20
@@ -259,7 +259,7 @@
CryptoTestUtils::ProofSourceForTesting());
MockClock clock;
- scoped_ptr<CryptoHandshakeMessage> message(server.AddDefaultConfig(
+ std::unique_ptr<CryptoHandshakeMessage> message(server.AddDefaultConfig(
rand, &clock, QuicCryptoServerConfig::ConfigOptions()));
// The default configuration should only contain AES-GCM when ChaCha20 has
@@ -282,7 +282,7 @@
server.SetStrikeRegisterClient(strike_register);
QuicCryptoServerConfig::ConfigOptions options;
- scoped_ptr<CryptoHandshakeMessage> message(
+ std::unique_ptr<CryptoHandshakeMessage> message(
server.AddDefaultConfig(rand, &clock, options));
EXPECT_TRUE(strike_register->is_known_orbit_called());
}
@@ -372,7 +372,7 @@
// Compress a similar certs which only differs in common certs field.
static const uint64_t set_hash = 42;
- scoped_ptr<CommonCertSets> common_sets(
+ std::unique_ptr<CommonCertSets> common_sets(
CryptoTestUtils::MockCommonCertSets(certs[0], set_hash, 1));
StringPiece different_common_certs(reinterpret_cast<const char*>(&set_hash),
sizeof(set_hash));
@@ -463,9 +463,9 @@
QuicCryptoServerConfig server_;
QuicCryptoServerConfigPeer peer_;
// Stores the primary config.
- scoped_ptr<CryptoHandshakeMessage> primary_config_;
- scoped_ptr<QuicServerConfigProtobuf> override_config_protobuf_;
- scoped_ptr<CryptoHandshakeMessage> override_config_;
+ std::unique_ptr<CryptoHandshakeMessage> primary_config_;
+ std::unique_ptr<QuicServerConfigProtobuf> override_config_protobuf_;
+ std::unique_ptr<CryptoHandshakeMessage> override_config_;
};
// Test basic behavior of source address tokens including being specific
@@ -572,7 +572,7 @@
StringPiece message("hello world");
const size_t key_size = CryptoSecretBoxer::GetKeySize();
- scoped_ptr<uint8_t[]> key(new uint8_t[key_size]);
+ std::unique_ptr<uint8_t[]> key(new uint8_t[key_size]);
memset(key.get(), 0x11, key_size);
CryptoSecretBoxer boxer;
diff --git a/net/quic/crypto/strike_register.h b/net/quic/crypto/strike_register.h
index fd3f5a7..9d7431b 100644
--- a/net/quic/crypto/strike_register.h
+++ b/net/quic/crypto/strike_register.h
@@ -7,12 +7,12 @@
#include <stdint.h>
+#include <memory>
#include <set>
#include <utility>
#include <vector>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
namespace net {
@@ -213,7 +213,7 @@
// internal_nodes_ can't be a scoped_ptr because the type isn't defined in
// this header.
InternalNode* internal_nodes_;
- scoped_ptr<uint8_t[]> external_nodes_;
+ std::unique_ptr<uint8_t[]> external_nodes_;
DISALLOW_COPY_AND_ASSIGN(StrikeRegister);
};
diff --git a/net/quic/crypto/strike_register_test.cc b/net/quic/crypto/strike_register_test.cc
index 2fca33f..0f63969 100644
--- a/net/quic/crypto/strike_register_test.cc
+++ b/net/quic/crypto/strike_register_test.cc
@@ -291,10 +291,10 @@
unsigned max_entries = 64;
uint32_t current_time = 10000, window = 200;
- scoped_ptr<StrikeRegister> s1(
+ std::unique_ptr<StrikeRegister> s1(
new StrikeRegister(max_entries, current_time, window, kOrbit,
StrikeRegister::DENY_REQUESTS_AT_STARTUP));
- scoped_ptr<SlowStrikeRegister> s2(
+ std::unique_ptr<SlowStrikeRegister> s2(
new SlowStrikeRegister(max_entries, current_time, window, kOrbit));
uint64_t i;
@@ -342,10 +342,10 @@
srand(42);
unsigned max_entries = 64;
uint32_t current_time = 10000, window = 200;
- scoped_ptr<StrikeRegister> s1(
+ std::unique_ptr<StrikeRegister> s1(
new StrikeRegister(max_entries, current_time, window, kOrbit,
StrikeRegister::DENY_REQUESTS_AT_STARTUP));
- scoped_ptr<SlowStrikeRegister> s2(
+ std::unique_ptr<SlowStrikeRegister> s2(
new SlowStrikeRegister(max_entries, current_time, window, kOrbit));
uint64_t i;
diff --git a/net/quic/iovector_test.cc b/net/quic/iovector_test.cc
index 7a1d00a..4435459 100644
--- a/net/quic/iovector_test.cc
+++ b/net/quic/iovector_test.cc
@@ -6,8 +6,9 @@
#include <string.h>
+#include <memory>
+
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "net/test/gtest_util.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -224,7 +225,7 @@
ASSERT_EQ(str_len, iov2[0].iov_len);
// Consume half of the first block.
- scoped_ptr<char[]> buffer(new char[str_len]);
+ std::unique_ptr<char[]> buffer(new char[str_len]);
size_t consumed = iov.ConsumeAndCopy(tmp, buffer.get());
EXPECT_EQ(0, memcmp(test_data[i], buffer.get(), tmp));
ASSERT_EQ(tmp, consumed);
@@ -262,7 +263,7 @@
const size_t half_len = last_len / 2;
const char* endp = iov.LastBlockEnd();
- scoped_ptr<char[]> buffer(new char[length]);
+ std::unique_ptr<char[]> buffer(new char[length]);
size_t consumed = iov.ConsumeAndCopy(length - half_len, buffer.get());
ASSERT_EQ(length - half_len, consumed);
const struct iovec* iov2 = iov.iovec();
@@ -292,7 +293,7 @@
}
int consumed = 0;
- scoped_ptr<char[]> buffer(new char[length + 1]);
+ std::unique_ptr<char[]> buffer(new char[length + 1]);
EXPECT_DFATAL({ consumed = iov.ConsumeAndCopy(length + 1, buffer.get()); },
"Attempting to consume 1 non-existent bytes.");
ASSERT_EQ(length, consumed);
diff --git a/net/quic/p2p/quic_p2p_session.cc b/net/quic/p2p/quic_p2p_session.cc
index 7b411e02..94777b3 100644
--- a/net/quic/p2p/quic_p2p_session.cc
+++ b/net/quic/p2p/quic_p2p_session.cc
@@ -19,8 +19,8 @@
QuicP2PSession::QuicP2PSession(const QuicConfig& config,
const QuicP2PCryptoConfig& crypto_config,
- scoped_ptr<QuicConnection> connection,
- scoped_ptr<Socket> socket)
+ std::unique_ptr<QuicConnection> connection,
+ std::unique_ptr<Socket> socket)
: QuicSession(connection.release(), config),
socket_(std::move(socket)),
crypto_stream_(new QuicP2PCryptoStream(this, crypto_config)),
diff --git a/net/quic/p2p/quic_p2p_session.h b/net/quic/p2p/quic_p2p_session.h
index ce02958..dcb1db1 100644
--- a/net/quic/p2p/quic_p2p_session.h
+++ b/net/quic/p2p/quic_p2p_session.h
@@ -5,8 +5,9 @@
#ifndef NET_QUIC_P2P_QUIC_P2P_SESSION_H_
#define NET_QUIC_P2P_QUIC_P2P_SESSION_H_
+#include <memory>
+
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/quic/p2p/quic_p2p_stream.h"
#include "net/quic/quic_client_session_base.h"
@@ -43,8 +44,8 @@
// shared with the peer.
QuicP2PSession(const QuicConfig& config,
const QuicP2PCryptoConfig& crypto_config,
- scoped_ptr<QuicConnection> connection,
- scoped_ptr<Socket> socket);
+ std::unique_ptr<QuicConnection> connection,
+ std::unique_ptr<Socket> socket);
~QuicP2PSession() override;
// QuicSession overrides.
@@ -76,8 +77,8 @@
int DoRead();
int DoReadComplete(int result);
- scoped_ptr<Socket> socket_;
- scoped_ptr<QuicP2PCryptoStream> crypto_stream_;
+ std::unique_ptr<Socket> socket_;
+ std::unique_ptr<QuicP2PCryptoStream> crypto_stream_;
Delegate* delegate_ = nullptr;
diff --git a/net/quic/p2p/quic_p2p_session_test.cc b/net/quic/p2p/quic_p2p_session_test.cc
index c9f248e..02230690 100644
--- a/net/quic/p2p/quic_p2p_session_test.cc
+++ b/net/quic/p2p/quic_p2p_session_test.cc
@@ -208,8 +208,8 @@
}
void CreateSessions() {
- scoped_ptr<FakeP2PDatagramSocket> socket1(new FakeP2PDatagramSocket());
- scoped_ptr<FakeP2PDatagramSocket> socket2(new FakeP2PDatagramSocket());
+ std::unique_ptr<FakeP2PDatagramSocket> socket1(new FakeP2PDatagramSocket());
+ std::unique_ptr<FakeP2PDatagramSocket> socket2(new FakeP2PDatagramSocket());
socket1->ConnectWith(socket2.get());
socket1_ = socket1->GetWeakPtr();
@@ -223,17 +223,18 @@
Perspective::IS_CLIENT);
}
- scoped_ptr<QuicP2PSession> CreateP2PSession(scoped_ptr<Socket> socket,
- QuicP2PCryptoConfig crypto_config,
- Perspective perspective) {
+ std::unique_ptr<QuicP2PSession> CreateP2PSession(
+ std::unique_ptr<Socket> socket,
+ QuicP2PCryptoConfig crypto_config,
+ Perspective perspective) {
QuicChromiumPacketWriter* writer =
new QuicChromiumPacketWriter(socket.get());
- scoped_ptr<QuicConnection> quic_connection1(new QuicConnection(
+ std::unique_ptr<QuicConnection> quic_connection1(new QuicConnection(
0, IPEndPoint(IPAddress::IPv4AllZeros(), 0), &quic_helper_, writer,
true /* owns_writer */, perspective, QuicSupportedVersions()));
writer->SetConnection(quic_connection1.get());
- scoped_ptr<QuicP2PSession> result(
+ std::unique_ptr<QuicP2PSession> result(
new QuicP2PSession(config_, crypto_config, std::move(quic_connection1),
std::move(socket)));
result->Initialize();
@@ -249,10 +250,10 @@
QuicConfig config_;
base::WeakPtr<FakeP2PDatagramSocket> socket1_;
- scoped_ptr<QuicP2PSession> session1_;
+ std::unique_ptr<QuicP2PSession> session1_;
base::WeakPtr<FakeP2PDatagramSocket> socket2_;
- scoped_ptr<QuicP2PSession> session2_;
+ std::unique_ptr<QuicP2PSession> session2_;
};
void QuicP2PSessionTest::OnWriteResult(int result) {
diff --git a/net/quic/quic_alarm.h b/net/quic/quic_alarm.h
index 53a823f..ed492cfe 100644
--- a/net/quic/quic_alarm.h
+++ b/net/quic/quic_alarm.h
@@ -5,8 +5,9 @@
#ifndef NET_QUIC_QUIC_ALARM_H_
#define NET_QUIC_QUIC_ALARM_H_
+#include <memory>
+
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
#include "net/quic/quic_arena_scoped_ptr.h"
#include "net/quic/quic_time.h"
diff --git a/net/quic/quic_chromium_client_session.cc b/net/quic/quic_chromium_client_session.cc
index 32b8de5c..6b454c8e 100644
--- a/net/quic/quic_chromium_client_session.cc
+++ b/net/quic/quic_chromium_client_session.cc
@@ -8,6 +8,7 @@
#include "base/callback_helpers.h"
#include "base/location.h"
+#include "base/memory/ptr_util.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/sparse_histogram.h"
#include "base/single_thread_task_runner.h"
@@ -115,12 +116,12 @@
NUM_HANDSHAKE_STATES);
}
-scoped_ptr<base::Value> NetLogQuicClientSessionCallback(
+std::unique_ptr<base::Value> NetLogQuicClientSessionCallback(
const QuicServerId* server_id,
int cert_verify_flags,
bool require_confirmation,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("host", server_id->host());
dict->SetInteger("port", server_id->port());
dict->SetBoolean("privacy_mode",
@@ -130,10 +131,10 @@
return std::move(dict);
}
-scoped_ptr<base::ListValue> SpdyHeaderBlockToListValue(
+std::unique_ptr<base::ListValue> SpdyHeaderBlockToListValue(
const SpdyHeaderBlock& headers,
NetLogCaptureMode capture_mode) {
- scoped_ptr<base::ListValue> headers_list(new base::ListValue());
+ std::unique_ptr<base::ListValue> headers_list(new base::ListValue());
for (const auto& it : headers) {
headers_list->AppendString(
it.first.as_string() + ": " +
@@ -143,12 +144,12 @@
return headers_list;
}
-scoped_ptr<base::Value> NetLogQuicPushPromiseReceivedCallback(
+std::unique_ptr<base::Value> NetLogQuicPushPromiseReceivedCallback(
const SpdyHeaderBlock* headers,
SpdyStreamId stream_id,
SpdyStreamId promised_stream_id,
NetLogCaptureMode capture_mode) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->Set("headers", SpdyHeaderBlockToListValue(*headers, capture_mode));
dict->SetInteger("id", stream_id);
dict->SetInteger("promised_stream_id", promised_stream_id);
@@ -199,12 +200,12 @@
QuicChromiumClientSession::QuicChromiumClientSession(
QuicConnection* connection,
- scoped_ptr<DatagramClientSocket> socket,
+ std::unique_ptr<DatagramClientSocket> socket,
QuicStreamFactory* stream_factory,
QuicCryptoClientStreamFactory* crypto_client_stream_factory,
QuicClock* clock,
TransportSecurityState* transport_security_state,
- scoped_ptr<QuicServerInfo> server_info,
+ std::unique_ptr<QuicServerInfo> server_info,
const QuicServerId& server_id,
int yield_after_packets,
QuicTime::Delta yield_after_duration,
@@ -215,7 +216,7 @@
base::TimeTicks dns_resolution_end_time,
QuicClientPushPromiseIndex* push_promise_index,
base::TaskRunner* task_runner,
- scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher,
+ std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
NetLog* net_log)
: QuicClientSessionBase(connection, push_promise_index, config),
server_id_(server_id),
@@ -239,12 +240,12 @@
streams_pushed_and_claimed_count_(0),
weak_factory_(this) {
sockets_.push_back(std::move(socket));
- packet_readers_.push_back(make_scoped_ptr(new QuicChromiumPacketReader(
+ packet_readers_.push_back(base::WrapUnique(new QuicChromiumPacketReader(
sockets_.back().get(), clock, this, yield_after_packets,
yield_after_duration, net_log_)));
crypto_stream_.reset(
crypto_client_stream_factory->CreateQuicCryptoClientStream(
- server_id, this, make_scoped_ptr(new ProofVerifyContextChromium(
+ server_id, this, base::WrapUnique(new ProofVerifyContextChromium(
cert_verify_flags, net_log_)),
crypto_config));
connection->set_debug_visitor(logger_.get());
@@ -954,7 +955,7 @@
cert_verify_result_.reset(new CertVerifyResult);
cert_verify_result_->CopyFrom(verify_details_chromium->cert_verify_result);
pinning_failure_log_ = verify_details_chromium->pinning_failure_log;
- scoped_ptr<ct::CTVerifyResult> ct_verify_result_copy(
+ std::unique_ptr<ct::CTVerifyResult> ct_verify_result_copy(
new ct::CTVerifyResult(verify_details_chromium->ct_verify_result));
ct_verify_result_ = std::move(ct_verify_result_copy);
logger_->OnCertificateVerified(*cert_verify_result_);
@@ -1020,12 +1021,12 @@
}
}
-scoped_ptr<base::Value> QuicChromiumClientSession::GetInfoAsValue(
+std::unique_ptr<base::Value> QuicChromiumClientSession::GetInfoAsValue(
const std::set<HostPortPair>& aliases) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("version", QuicVersionToString(connection()->version()));
dict->SetInteger("open_streams", GetNumOpenOutgoingStreams());
- scoped_ptr<base::ListValue> stream_list(new base::ListValue());
+ std::unique_ptr<base::ListValue> stream_list(new base::ListValue());
for (StreamMap::const_iterator it = dynamic_streams().begin();
it != dynamic_streams().end(); ++it) {
stream_list->Append(
@@ -1044,7 +1045,7 @@
SSLInfo ssl_info;
dict->SetBoolean("secure", GetSSLInfo(&ssl_info) && ssl_info.cert.get());
- scoped_ptr<base::ListValue> alias_list(new base::ListValue());
+ std::unique_ptr<base::ListValue> alias_list(new base::ListValue());
for (std::set<HostPortPair>::const_iterator it = aliases.begin();
it != aliases.end(); it++) {
alias_list->Append(new base::StringValue(it->ToString()));
@@ -1137,9 +1138,9 @@
}
bool QuicChromiumClientSession::MigrateToSocket(
- scoped_ptr<DatagramClientSocket> socket,
- scoped_ptr<QuicChromiumPacketReader> reader,
- scoped_ptr<QuicPacketWriter> writer) {
+ std::unique_ptr<DatagramClientSocket> socket,
+ std::unique_ptr<QuicChromiumPacketReader> reader,
+ std::unique_ptr<QuicPacketWriter> writer) {
DCHECK_EQ(sockets_.size(), packet_readers_.size());
if (sockets_.size() >= kMaxReadersPerQuicSession) {
return false;
diff --git a/net/quic/quic_chromium_client_session.h b/net/quic/quic_chromium_client_session.h
index a9e636b6..f40be75 100644
--- a/net/quic/quic_chromium_client_session.h
+++ b/net/quic/quic_chromium_client_session.h
@@ -12,11 +12,11 @@
#include <stddef.h>
+#include <memory>
#include <string>
#include "base/containers/mru_cache.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/time/time.h"
#include "net/base/completion_callback.h"
#include "net/base/net_error_details.h"
@@ -116,12 +116,12 @@
// TODO(rch): decouple the factory from the session via a Delegate interface.
QuicChromiumClientSession(
QuicConnection* connection,
- scoped_ptr<DatagramClientSocket> socket,
+ std::unique_ptr<DatagramClientSocket> socket,
QuicStreamFactory* stream_factory,
QuicCryptoClientStreamFactory* crypto_client_stream_factory,
QuicClock* clock,
TransportSecurityState* transport_security_state,
- scoped_ptr<QuicServerInfo> server_info,
+ std::unique_ptr<QuicServerInfo> server_info,
const QuicServerId& server_id,
int yield_after_packets,
QuicTime::Delta yield_after_duration,
@@ -132,7 +132,7 @@
base::TimeTicks dns_resolution_end_time,
QuicClientPushPromiseIndex* push_promise_index,
base::TaskRunner* task_runner,
- scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher,
+ std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
NetLog* net_log);
~QuicChromiumClientSession() override;
@@ -218,7 +218,8 @@
void CloseSessionOnErrorAndNotifyFactoryLater(int error,
QuicErrorCode quic_error);
- scoped_ptr<base::Value> GetInfoAsValue(const std::set<HostPortPair>& aliases);
+ std::unique_ptr<base::Value> GetInfoAsValue(
+ const std::set<HostPortPair>& aliases);
const BoundNetLog& net_log() const { return net_log_; }
@@ -244,9 +245,9 @@
// session and the session was successfully migrated to using the new socket.
// Returns false if number of migrations exceeds kMaxReadersPerQuicSession.
// Takes ownership of |socket|, |reader|, and |writer|.
- bool MigrateToSocket(scoped_ptr<DatagramClientSocket> socket,
- scoped_ptr<QuicChromiumPacketReader> reader,
- scoped_ptr<QuicPacketWriter> writer);
+ bool MigrateToSocket(std::unique_ptr<DatagramClientSocket> socket,
+ std::unique_ptr<QuicChromiumPacketReader> reader,
+ std::unique_ptr<QuicPacketWriter> writer);
// Populates network error details for this session.
void PopulateNetErrorDetails(NetErrorDetails* details);
@@ -319,13 +320,13 @@
QuicServerId server_id_;
bool require_confirmation_;
- scoped_ptr<QuicCryptoClientStream> crypto_stream_;
+ std::unique_ptr<QuicCryptoClientStream> crypto_stream_;
QuicStreamFactory* stream_factory_;
- std::vector<scoped_ptr<DatagramClientSocket>> sockets_;
+ std::vector<std::unique_ptr<DatagramClientSocket>> sockets_;
TransportSecurityState* transport_security_state_;
- scoped_ptr<QuicServerInfo> server_info_;
- scoped_ptr<CertVerifyResult> cert_verify_result_;
- scoped_ptr<ct::CTVerifyResult> ct_verify_result_;
+ std::unique_ptr<QuicServerInfo> server_info_;
+ std::unique_ptr<CertVerifyResult> cert_verify_result_;
+ std::unique_ptr<ct::CTVerifyResult> ct_verify_result_;
std::string pinning_failure_log_;
ObserverSet observers_;
StreamRequestQueue stream_requests_;
@@ -333,10 +334,10 @@
size_t num_total_streams_;
base::TaskRunner* task_runner_;
BoundNetLog net_log_;
- std::vector<scoped_ptr<QuicChromiumPacketReader>> packet_readers_;
+ std::vector<std::unique_ptr<QuicChromiumPacketReader>> packet_readers_;
base::TimeTicks dns_resolution_end_time_;
base::TimeTicks handshake_start_; // Time the handshake was started.
- scoped_ptr<QuicConnectionLogger> logger_;
+ std::unique_ptr<QuicConnectionLogger> logger_;
// True when the session is going away, and streams may no longer be created
// on this session. Existing stream will continue to be processed.
bool going_away_;
diff --git a/net/quic/quic_chromium_client_session_test.cc b/net/quic/quic_chromium_client_session_test.cc
index 40f40e2..a17b663ce 100644
--- a/net/quic/quic_chromium_client_session_test.cc
+++ b/net/quic/quic_chromium_client_session_test.cc
@@ -8,6 +8,7 @@
#include "base/base64.h"
#include "base/files/file_path.h"
+#include "base/memory/ptr_util.h"
#include "base/rand_util.h"
#include "base/thread_task_runner_handle.h"
#include "net/base/socket_performance_watcher.h"
@@ -70,7 +71,7 @@
void Initialize() {
socket_factory_.AddSocketDataProvider(socket_data_.get());
- scoped_ptr<DatagramClientSocket> socket =
+ std::unique_ptr<DatagramClientSocket> socket =
socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
base::Bind(&base::RandInt),
&net_log_, NetLog::Source());
@@ -84,7 +85,7 @@
session_.reset(new QuicChromiumClientSession(
connection, std::move(socket),
/*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
- &transport_security_state_, make_scoped_ptr((QuicServerInfo*)nullptr),
+ &transport_security_state_, base::WrapUnique((QuicServerInfo*)nullptr),
QuicServerId(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED),
kQuicYieldAfterPacketsRead,
QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
@@ -111,7 +112,7 @@
QuicPacketWriter* CreateQuicPacketWriter(DatagramClientSocket* socket,
QuicConnection* connection) const {
- scoped_ptr<QuicChromiumPacketWriter> writer(
+ std::unique_ptr<QuicChromiumPacketWriter> writer(
new QuicChromiumPacketWriter(socket));
writer->SetConnection(connection);
return writer.release();
@@ -121,14 +122,14 @@
TestNetLog net_log_;
BoundTestNetLog bound_net_log_;
MockClientSocketFactory socket_factory_;
- scoped_ptr<MockRead> default_read_;
- scoped_ptr<SequencedSocketData> socket_data_;
+ std::unique_ptr<MockRead> default_read_;
+ std::unique_ptr<SequencedSocketData> socket_data_;
MockClock clock_;
MockRandom random_;
QuicChromiumConnectionHelper helper_;
TransportSecurityState transport_security_state_;
MockCryptoClientStreamFactory crypto_client_stream_factory_;
- scoped_ptr<QuicChromiumClientSession> session_;
+ std::unique_ptr<QuicChromiumClientSession> session_;
QuicConnectionVisitorInterface* visitor_;
TestCompletionCallback callback_;
QuicTestPacketMaker maker_;
@@ -147,7 +148,7 @@
TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
MockWrite writes[] = {
MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1)};
@@ -182,7 +183,7 @@
TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
MockWrite writes[] = {
MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1)};
@@ -330,10 +331,11 @@
CompleteCryptoHandshake();
char data[] = "ABCD";
- scoped_ptr<QuicEncryptedPacket> ping(
+ std::unique_ptr<QuicEncryptedPacket> ping(
maker_.MakePingPacket(1, /*include_version=*/false));
- scoped_ptr<QuicEncryptedPacket> ack_and_data_out(maker_.MakeAckAndDataPacket(
- 2, false, 5, 1, 1, false, 0, StringPiece(data)));
+ std::unique_ptr<QuicEncryptedPacket> ack_and_data_out(
+ maker_.MakeAckAndDataPacket(2, false, 5, 1, 1, false, 0,
+ StringPiece(data)));
MockRead reads[] = {MockRead(SYNCHRONOUS, ping->data(), ping->length(), 0),
MockRead(SYNCHRONOUS, ERR_IO_PENDING, 1)};
MockWrite writes[] = {MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 2),
@@ -344,18 +346,20 @@
socket_factory_.AddSocketDataProvider(&socket_data);
// Create connected socket.
- scoped_ptr<DatagramClientSocket> new_socket =
+ std::unique_ptr<DatagramClientSocket> new_socket =
socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
base::Bind(&base::RandInt),
&net_log_, NetLog::Source());
EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
// Create reader and writer.
- scoped_ptr<QuicChromiumPacketReader> new_reader(new QuicChromiumPacketReader(
- new_socket.get(), &clock_, session_.get(), kQuicYieldAfterPacketsRead,
- QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
- bound_net_log_.bound()));
- scoped_ptr<QuicPacketWriter> new_writer(
+ std::unique_ptr<QuicChromiumPacketReader> new_reader(
+ new QuicChromiumPacketReader(new_socket.get(), &clock_, session_.get(),
+ kQuicYieldAfterPacketsRead,
+ QuicTime::Delta::FromMilliseconds(
+ kQuicYieldAfterDurationMilliseconds),
+ bound_net_log_.bound()));
+ std::unique_ptr<QuicPacketWriter> new_writer(
CreateQuicPacketWriter(new_socket.get(), session_->connection()));
// Migrate session.
@@ -379,7 +383,7 @@
for (size_t i = 0; i < kMaxReadersPerQuicSession; ++i) {
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 1)};
- scoped_ptr<QuicEncryptedPacket> ping_out(
+ std::unique_ptr<QuicEncryptedPacket> ping_out(
maker_.MakePingPacket(i + 1, /*include_version=*/true));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, ping_out->data(), ping_out->length(), i + 2)};
@@ -388,20 +392,20 @@
socket_factory_.AddSocketDataProvider(&socket_data);
// Create connected socket.
- scoped_ptr<DatagramClientSocket> new_socket =
+ std::unique_ptr<DatagramClientSocket> new_socket =
socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
base::Bind(&base::RandInt),
&net_log_, NetLog::Source());
EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
// Create reader and writer.
- scoped_ptr<QuicChromiumPacketReader> new_reader(
+ std::unique_ptr<QuicChromiumPacketReader> new_reader(
new QuicChromiumPacketReader(new_socket.get(), &clock_, session_.get(),
kQuicYieldAfterPacketsRead,
QuicTime::Delta::FromMilliseconds(
kQuicYieldAfterDurationMilliseconds),
bound_net_log_.bound()));
- scoped_ptr<QuicPacketWriter> new_writer(
+ std::unique_ptr<QuicPacketWriter> new_writer(
CreateQuicPacketWriter(new_socket.get(), session_->connection()));
// Migrate session.
@@ -422,7 +426,7 @@
}
TEST_P(QuicChromiumClientSessionTest, MigrateToSocketReadError) {
- scoped_ptr<QuicEncryptedPacket> ping(
+ std::unique_ptr<QuicEncryptedPacket> ping(
maker_.MakePingPacket(1, /*include_version=*/true));
MockRead old_reads[] = {
MockRead(SYNCHRONOUS, ping->data(), ping->length(), 0),
@@ -446,18 +450,20 @@
socket_factory_.AddSocketDataProvider(&new_socket_data);
// Create connected socket.
- scoped_ptr<DatagramClientSocket> new_socket =
+ std::unique_ptr<DatagramClientSocket> new_socket =
socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
base::Bind(&base::RandInt),
&net_log_, NetLog::Source());
EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
// Create reader and writer.
- scoped_ptr<QuicChromiumPacketReader> new_reader(new QuicChromiumPacketReader(
- new_socket.get(), &clock_, session_.get(), kQuicYieldAfterPacketsRead,
- QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
- bound_net_log_.bound()));
- scoped_ptr<QuicPacketWriter> new_writer(
+ std::unique_ptr<QuicChromiumPacketReader> new_reader(
+ new QuicChromiumPacketReader(new_socket.get(), &clock_, session_.get(),
+ kQuicYieldAfterPacketsRead,
+ QuicTime::Delta::FromMilliseconds(
+ kQuicYieldAfterDurationMilliseconds),
+ bound_net_log_.bound()));
+ std::unique_ptr<QuicPacketWriter> new_writer(
CreateQuicPacketWriter(new_socket.get(), session_->connection()));
// Store old socket and migrate session.
@@ -487,7 +493,7 @@
Initialize();
CompleteCryptoHandshake();
- scoped_ptr<QuicEncryptedPacket> ping(
+ std::unique_ptr<QuicEncryptedPacket> ping(
maker_.MakePingPacket(1, /*include_version=*/true));
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
MockWrite writes[] = {MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 1),
@@ -497,18 +503,20 @@
socket_factory_.AddSocketDataProvider(&socket_data);
// Create connected socket.
- scoped_ptr<DatagramClientSocket> new_socket =
+ std::unique_ptr<DatagramClientSocket> new_socket =
socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
base::Bind(&base::RandInt),
&net_log_, NetLog::Source());
EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
// Create reader and writer.
- scoped_ptr<QuicChromiumPacketReader> new_reader(new QuicChromiumPacketReader(
- new_socket.get(), &clock_, session_.get(), kQuicYieldAfterPacketsRead,
- QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
- bound_net_log_.bound()));
- scoped_ptr<QuicPacketWriter> new_writer(
+ std::unique_ptr<QuicChromiumPacketReader> new_reader(
+ new QuicChromiumPacketReader(new_socket.get(), &clock_, session_.get(),
+ kQuicYieldAfterPacketsRead,
+ QuicTime::Delta::FromMilliseconds(
+ kQuicYieldAfterDurationMilliseconds),
+ bound_net_log_.bound()));
+ std::unique_ptr<QuicPacketWriter> new_writer(
CreateQuicPacketWriter(new_socket.get(), session_->connection()));
// Migrate session.
diff --git a/net/quic/quic_chromium_client_stream_test.cc b/net/quic/quic_chromium_client_stream_test.cc
index 94d20a9a..4b1d31ed 100644
--- a/net/quic/quic_chromium_client_stream_test.cc
+++ b/net/quic/quic_chromium_client_stream_test.cc
@@ -119,7 +119,7 @@
MOCK_METHOD0(ShouldCreateOutgoingDynamicStream, bool());
private:
- scoped_ptr<QuicCryptoStream> crypto_stream_;
+ std::unique_ptr<QuicCryptoStream> crypto_stream_;
DISALLOW_COPY_AND_ASSIGN(MockQuicClientSessionBase);
};
diff --git a/net/quic/quic_chromium_connection_helper_test.cc b/net/quic/quic_chromium_connection_helper_test.cc
index 9fab8fb5..2774d17 100644
--- a/net/quic/quic_chromium_connection_helper_test.cc
+++ b/net/quic/quic_chromium_connection_helper_test.cc
@@ -48,7 +48,7 @@
TEST_F(QuicChromiumConnectionHelperTest, CreateAlarm) {
TestDelegate* delegate = new TestDelegate();
- scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
+ std::unique_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock_.Now().Add(delta));
@@ -65,7 +65,7 @@
TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndCancel) {
TestDelegate* delegate = new TestDelegate();
- scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
+ std::unique_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock_.Now().Add(delta));
@@ -83,7 +83,7 @@
TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndReset) {
TestDelegate* delegate = new TestDelegate();
- scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
+ std::unique_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock_.Now().Add(delta));
@@ -110,7 +110,7 @@
TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndResetEarlier) {
TestDelegate* delegate = new TestDelegate();
- scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
+ std::unique_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(3);
alarm->Set(clock_.Now().Add(delta));
@@ -139,7 +139,7 @@
TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndUpdate) {
TestDelegate* delegate = new TestDelegate();
- scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
+ std::unique_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
const QuicClock* clock = helper_.GetClock();
QuicTime start = clock->Now();
diff --git a/net/quic/quic_client_promised_info_test.cc b/net/quic/quic_client_promised_info_test.cc
index 1084cae..df4694c 100644
--- a/net/quic/quic_client_promised_info_test.cc
+++ b/net/quic/quic_client_promised_info_test.cc
@@ -146,9 +146,9 @@
QuicClientPushPromiseIndex push_promise_index_;
MockQuicClientSession session_;
- scoped_ptr<QuicSpdyClientStream> stream_;
- scoped_ptr<StreamVisitor> stream_visitor_;
- scoped_ptr<QuicSpdyClientStream> promised_stream_;
+ std::unique_ptr<QuicSpdyClientStream> stream_;
+ std::unique_ptr<StreamVisitor> stream_visitor_;
+ std::unique_ptr<QuicSpdyClientStream> promised_stream_;
BalsaHeaders headers_;
string headers_string_;
string body_;
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index 7ce76a8..60f5395 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -1088,7 +1088,7 @@
}
DVLOG(1) << ENDPOINT << "Sending version negotiation packet: {"
<< QuicVersionVectorToString(framer_.supported_versions()) << "}";
- scoped_ptr<QuicEncryptedPacket> version_packet(
+ std::unique_ptr<QuicEncryptedPacket> version_packet(
packet_generator_.SerializeVersionNegotiationPacket(
framer_.supported_versions()));
WriteResult result = writer_->WritePacket(
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
index 5baff2e..597edd5 100644
--- a/net/quic/quic_connection.h
+++ b/net/quic/quic_connection.h
@@ -22,13 +22,13 @@
#include <deque>
#include <list>
#include <map>
+#include <memory>
#include <queue>
#include <string>
#include <vector>
#include "base/logging.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
@@ -909,7 +909,7 @@
bool save_crypto_packets_as_termination_packets_;
// Contains the connection close packets if the connection has been closed.
- scoped_ptr<std::vector<QuicEncryptedPacket*>> termination_packets_;
+ std::unique_ptr<std::vector<QuicEncryptedPacket*>> termination_packets_;
// Determines whether or not a connection close packet is sent to the peer
// after idle timeout due to lack of network activity.
diff --git a/net/quic/quic_connection_logger.cc b/net/quic/quic_connection_logger.cc
index b9cb00e3..99f6991 100644
--- a/net/quic/quic_connection_logger.cc
+++ b/net/quic/quic_connection_logger.cc
@@ -38,24 +38,24 @@
// Hence the largest sample is bounded by the sum of those numbers.
const int kBoundingSampleInCumulativeHistogram = ((2 + 22) * 21) / 2;
-scoped_ptr<base::Value> NetLogQuicPacketCallback(
+std::unique_ptr<base::Value> NetLogQuicPacketCallback(
const IPEndPoint* self_address,
const IPEndPoint* peer_address,
size_t packet_size,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("self_address", self_address->ToString());
dict->SetString("peer_address", peer_address->ToString());
dict->SetInteger("size", packet_size);
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicPacketSentCallback(
+std::unique_ptr<base::Value> NetLogQuicPacketSentCallback(
const SerializedPacket& serialized_packet,
TransmissionType transmission_type,
QuicTime sent_time,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("transmission_type", transmission_type);
dict->SetString("packet_number",
base::Uint64ToString(serialized_packet.packet_number));
@@ -64,28 +64,28 @@
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicPacketRetransmittedCallback(
+std::unique_ptr<base::Value> NetLogQuicPacketRetransmittedCallback(
QuicPacketNumber old_packet_number,
QuicPacketNumber new_packet_number,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("old_packet_number", base::Uint64ToString(old_packet_number));
dict->SetString("new_packet_number", base::Uint64ToString(new_packet_number));
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicDuplicatePacketCallback(
+std::unique_ptr<base::Value> NetLogQuicDuplicatePacketCallback(
QuicPacketNumber packet_number,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("packet_number", base::Uint64ToString(packet_number));
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicPacketHeaderCallback(
+std::unique_ptr<base::Value> NetLogQuicPacketHeaderCallback(
const QuicPacketHeader* header,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("connection_id",
base::Uint64ToString(header->public_header.connection_id));
dict->SetInteger("reset_flag", header->public_header.reset_flag);
@@ -97,10 +97,10 @@
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicStreamFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicStreamFrameCallback(
const QuicStreamFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("stream_id", frame->stream_id);
dict->SetBoolean("fin", frame->fin);
dict->SetString("offset", base::Uint64ToString(frame->offset));
@@ -108,10 +108,10 @@
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicAckFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicAckFrameCallback(
const QuicAckFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("largest_observed",
base::Uint64ToString(frame->largest_observed));
dict->SetString("delta_time_largest_observed_us",
@@ -139,55 +139,55 @@
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicRstStreamFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicRstStreamFrameCallback(
const QuicRstStreamFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("stream_id", frame->stream_id);
dict->SetInteger("quic_rst_stream_error", frame->error_code);
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicConnectionCloseFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicConnectionCloseFrameCallback(
const QuicConnectionCloseFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("quic_error", frame->error_code);
dict->SetString("details", frame->error_details);
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicWindowUpdateFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicWindowUpdateFrameCallback(
const QuicWindowUpdateFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("stream_id", frame->stream_id);
dict->SetString("byte_offset", base::Uint64ToString(frame->byte_offset));
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicBlockedFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicBlockedFrameCallback(
const QuicBlockedFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("stream_id", frame->stream_id);
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicGoAwayFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicGoAwayFrameCallback(
const QuicGoAwayFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("quic_error", frame->error_code);
dict->SetInteger("last_good_stream_id", frame->last_good_stream_id);
dict->SetString("reason_phrase", frame->reason_phrase);
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicStopWaitingFrameCallback(
+std::unique_ptr<base::Value> NetLogQuicStopWaitingFrameCallback(
const QuicStopWaitingFrame* frame,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
base::DictionaryValue* sent_info = new base::DictionaryValue();
dict->Set("sent_info", sent_info);
sent_info->SetString("least_unacked",
@@ -195,10 +195,10 @@
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicVersionNegotiationPacketCallback(
+std::unique_ptr<base::Value> NetLogQuicVersionNegotiationPacketCallback(
const QuicVersionNegotiationPacket* packet,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
base::ListValue* versions = new base::ListValue();
dict->Set("versions", versions);
for (QuicVersionVector::const_iterator it = packet->versions.begin();
@@ -208,33 +208,33 @@
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicCryptoHandshakeMessageCallback(
+std::unique_ptr<base::Value> NetLogQuicCryptoHandshakeMessageCallback(
const CryptoHandshakeMessage* message,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("quic_crypto_handshake_message", message->DebugString());
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicOnConnectionClosedCallback(
+std::unique_ptr<base::Value> NetLogQuicOnConnectionClosedCallback(
QuicErrorCode error,
ConnectionCloseSource source,
NetLogCaptureMode /* capture_mode */) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("quic_error", error);
dict->SetBoolean("from_peer",
source == ConnectionCloseSource::FROM_PEER ? true : false);
return std::move(dict);
}
-scoped_ptr<base::Value> NetLogQuicCertificateVerifiedCallback(
+std::unique_ptr<base::Value> NetLogQuicCertificateVerifiedCallback(
scoped_refptr<X509Certificate> cert,
NetLogCaptureMode /* capture_mode */) {
// Only the subjects are logged so that we can investigate connection pooling.
// More fields could be logged in the future.
std::vector<std::string> dns_names;
cert->GetDNSNames(&dns_names);
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
base::ListValue* subjects = new base::ListValue();
for (std::vector<std::string>::const_iterator it = dns_names.begin();
it != dns_names.end(); it++) {
@@ -274,7 +274,7 @@
QuicConnectionLogger::QuicConnectionLogger(
QuicSpdySession* session,
const char* const connection_description,
- scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher,
+ std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
const BoundNetLog& net_log)
: net_log_(net_log),
session_(session),
diff --git a/net/quic/quic_connection_logger.h b/net/quic/quic_connection_logger.h
index ff2c917..a8f657db 100644
--- a/net/quic/quic_connection_logger.h
+++ b/net/quic/quic_connection_logger.h
@@ -35,7 +35,7 @@
QuicConnectionLogger(
QuicSpdySession* session,
const char* const connection_description,
- scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher,
+ std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
const BoundNetLog& net_log);
~QuicConnectionLogger() override;
@@ -185,7 +185,7 @@
const char* const connection_description_;
// Receives notifications regarding the performance of the underlying socket
// for the QUIC connection. May be null.
- const scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher_;
+ const std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher_;
DISALLOW_COPY_AND_ASSIGN(QuicConnectionLogger);
};
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index ee2ab97d..cf652af1 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -4,11 +4,11 @@
#include "net/quic/quic_connection.h"
+#include <memory>
#include <ostream>
#include "base/bind.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "net/base/ip_address.h"
#include "net/base/net_errors.h"
@@ -766,7 +766,7 @@
header.packet_number = number;
QuicFrames frames;
frames.push_back(frame);
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
@@ -789,7 +789,7 @@
bool entropy_flag,
bool has_stop_waiting,
EncryptionLevel level) {
- scoped_ptr<QuicPacket> packet(
+ std::unique_ptr<QuicPacket> packet(
ConstructDataPacket(path_id, number, entropy_flag, has_stop_waiting));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
@@ -804,7 +804,7 @@
}
void ProcessClosePacket(QuicPathId path_id, QuicPacketNumber number) {
- scoped_ptr<QuicPacket> packet(ConstructClosePacket(number));
+ std::unique_ptr<QuicPacket> packet(ConstructClosePacket(number));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_NONE, path_id, number, *packet, buffer, kMaxPacketSize);
@@ -994,9 +994,9 @@
MockClock clock_;
MockRandom random_generator_;
SimpleBufferAllocator buffer_allocator_;
- scoped_ptr<TestConnectionHelper> helper_;
+ std::unique_ptr<TestConnectionHelper> helper_;
QuicPacketCreator peer_creator_;
- scoped_ptr<TestPacketWriter> writer_;
+ std::unique_ptr<TestPacketWriter> writer_;
TestConnection connection_;
QuicPacketCreator* creator_;
QuicPacketGenerator* generator_;
@@ -1087,7 +1087,7 @@
QuicPaddingFrame padding;
frames.push_back(QuicFrame(&frame1_));
frames.push_back(QuicFrame(padding));
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
@@ -1121,7 +1121,7 @@
QuicPaddingFrame padding;
frames.push_back(QuicFrame(&frame1_));
frames.push_back(QuicFrame(padding));
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
@@ -3909,9 +3909,9 @@
header.public_header.reset_flag = true;
header.public_header.version_flag = false;
header.rejected_packet_number = 10101;
- scoped_ptr<QuicEncryptedPacket> packet(
+ std::unique_ptr<QuicEncryptedPacket> packet(
framer_.BuildPublicResetPacket(header));
- scoped_ptr<QuicReceivedPacket> received(
+ std::unique_ptr<QuicReceivedPacket> received(
ConstructReceivedPacket(*packet, QuicTime::Zero()));
EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PUBLIC_RESET, _,
ConnectionCloseSource::FROM_PEER));
@@ -4062,7 +4062,7 @@
QuicFrames frames;
frames.push_back(QuicFrame(&frame1_));
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
@@ -4097,7 +4097,7 @@
QuicFrames frames;
frames.push_back(QuicFrame(&frame1_));
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
@@ -4139,7 +4139,7 @@
QuicFrames frames;
frames.push_back(QuicFrame(&frame1_));
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
char buffer[kMaxPacketSize];
size_t encryped_length = framer_.EncryptPayload(
ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
@@ -4161,10 +4161,10 @@
->set_version_for_tests(QUIC_VERSION_UNSUPPORTED);
// Send a version negotiation packet.
- scoped_ptr<QuicEncryptedPacket> encrypted(
+ std::unique_ptr<QuicEncryptedPacket> encrypted(
framer_.BuildVersionNegotiationPacket(connection_id_,
QuicSupportedVersions()));
- scoped_ptr<QuicReceivedPacket> received(
+ std::unique_ptr<QuicReceivedPacket> received(
ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *received);
@@ -4177,7 +4177,7 @@
header.public_header.version_flag = false;
QuicFrames frames;
frames.push_back(QuicFrame(&frame1_));
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
@@ -4197,10 +4197,10 @@
EXPECT_CALL(visitor_,
OnConnectionClosed(QUIC_INVALID_VERSION_NEGOTIATION_PACKET, _,
ConnectionCloseSource::FROM_SELF));
- scoped_ptr<QuicEncryptedPacket> encrypted(
+ std::unique_ptr<QuicEncryptedPacket> encrypted(
framer_.BuildVersionNegotiationPacket(connection_id_,
QuicSupportedVersions()));
- scoped_ptr<QuicReceivedPacket> received(
+ std::unique_ptr<QuicReceivedPacket> received(
ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *received);
}
@@ -4265,7 +4265,7 @@
QuicFrames frames;
frames.push_back(QuicFrame(&frame1_));
frames.push_back(QuicFrame(&qccf));
- scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
+ std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
EXPECT_TRUE(nullptr != packet.get());
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
@@ -4498,7 +4498,7 @@
TEST_P(QuicConnectionTest, OnPacketHeaderDebugVisitor) {
QuicPacketHeader header;
- scoped_ptr<MockQuicConnectionDebugVisitor> debug_visitor(
+ std::unique_ptr<MockQuicConnectionDebugVisitor> debug_visitor(
new MockQuicConnectionDebugVisitor());
connection_.set_debug_visitor(debug_visitor.get());
EXPECT_CALL(*debug_visitor, OnPacketHeader(Ref(header))).Times(1);
diff --git a/net/quic/quic_crypto_client_stream.cc b/net/quic/quic_crypto_client_stream.cc
index f91d894..55f29a0 100644
--- a/net/quic/quic_crypto_client_stream.cc
+++ b/net/quic/quic_crypto_client_stream.cc
@@ -53,7 +53,7 @@
~ChannelIDSourceCallbackImpl() {}
void QuicCryptoClientStream::ChannelIDSourceCallbackImpl::Run(
- scoped_ptr<ChannelIDKey>* channel_id_key) {
+ std::unique_ptr<ChannelIDKey>* channel_id_key) {
if (stream_ == nullptr) {
return;
}
@@ -81,7 +81,7 @@
void QuicCryptoClientStream::ProofVerifierCallbackImpl::Run(
bool ok,
const string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) {
+ std::unique_ptr<ProofVerifyDetails>* details) {
if (stream_ == nullptr) {
return;
}
diff --git a/net/quic/quic_crypto_client_stream.h b/net/quic/quic_crypto_client_stream.h
index 30eb075..f9eabbb 100644
--- a/net/quic/quic_crypto_client_stream.h
+++ b/net/quic/quic_crypto_client_stream.h
@@ -108,7 +108,7 @@
~ChannelIDSourceCallbackImpl() override;
// ChannelIDSourceCallback interface.
- void Run(scoped_ptr<ChannelIDKey>* channel_id_key) override;
+ void Run(std::unique_ptr<ChannelIDKey>* channel_id_key) override;
// Cancel causes any future callbacks to be ignored. It must be called on
// the same thread as the callback will be made on.
@@ -129,7 +129,7 @@
// ProofVerifierCallback interface.
void Run(bool ok,
const std::string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) override;
+ std::unique_ptr<ProofVerifyDetails>* details) override;
// Cancel causes any future callbacks to be ignored. It must be called on
// the same thread as the callback will be made on.
@@ -239,11 +239,11 @@
// These members are used to store the result of an asynchronous channel ID
// lookup. These members must not be used after
// STATE_GET_CHANNEL_ID_COMPLETE.
- scoped_ptr<ChannelIDKey> channel_id_key_;
+ std::unique_ptr<ChannelIDKey> channel_id_key_;
// verify_context_ contains the context object that we pass to asynchronous
// proof verifications.
- scoped_ptr<ProofVerifyContext> verify_context_;
+ std::unique_ptr<ProofVerifyContext> verify_context_;
// proof_verify_callback_ contains the callback object that we passed to an
// asynchronous proof verification. The ProofVerifier owns this object.
@@ -257,7 +257,7 @@
// STATE_VERIFY_PROOF_COMPLETE.
bool verify_ok_;
std::string verify_error_details_;
- scoped_ptr<ProofVerifyDetails> verify_details_;
+ std::unique_ptr<ProofVerifyDetails> verify_details_;
// True if the server responded to a previous CHLO with a stateless
// reject. Used for book-keeping between the STATE_RECV_REJ,
diff --git a/net/quic/quic_crypto_client_stream_factory.cc b/net/quic/quic_crypto_client_stream_factory.cc
index 41ca05b..8c43218 100644
--- a/net/quic/quic_crypto_client_stream_factory.cc
+++ b/net/quic/quic_crypto_client_stream_factory.cc
@@ -18,7 +18,7 @@
QuicCryptoClientStream* CreateQuicCryptoClientStream(
const QuicServerId& server_id,
QuicChromiumClientSession* session,
- scoped_ptr<ProofVerifyContext> proof_verify_context,
+ std::unique_ptr<ProofVerifyContext> proof_verify_context,
QuicCryptoClientConfig* crypto_config) override {
return new QuicCryptoClientStream(server_id, session,
proof_verify_context.release(),
diff --git a/net/quic/quic_crypto_client_stream_factory.h b/net/quic/quic_crypto_client_stream_factory.h
index cd1d430..98460e1 100644
--- a/net/quic/quic_crypto_client_stream_factory.h
+++ b/net/quic/quic_crypto_client_stream_factory.h
@@ -5,9 +5,9 @@
#ifndef NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_FACTORY_H_
#define NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_FACTORY_H_
+#include <memory>
#include <string>
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
namespace net {
@@ -27,7 +27,7 @@
virtual QuicCryptoClientStream* CreateQuicCryptoClientStream(
const QuicServerId& server_id,
QuicChromiumClientSession* session,
- scoped_ptr<ProofVerifyContext> proof_verify_context,
+ std::unique_ptr<ProofVerifyContext> proof_verify_context,
QuicCryptoClientConfig* crypto_config) = 0;
static QuicCryptoClientStreamFactory* GetDefaultFactory();
diff --git a/net/quic/quic_crypto_client_stream_test.cc b/net/quic/quic_crypto_client_stream_test.cc
index 2909e37..54ecb914 100644
--- a/net/quic/quic_crypto_client_stream_test.cc
+++ b/net/quic/quic_crypto_client_stream_test.cc
@@ -4,7 +4,8 @@
#include "net/quic/quic_crypto_client_stream.h"
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
#include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
#include "net/quic/crypto/quic_decrypter.h"
#include "net/quic/crypto/quic_encrypter.h"
@@ -62,10 +63,10 @@
MockConnectionHelper helper_;
PacketSavingConnection* connection_;
- scoped_ptr<TestQuicSpdyClientSession> session_;
+ std::unique_ptr<TestQuicSpdyClientSession> session_;
QuicServerId server_id_;
CryptoHandshakeMessage message_;
- scoped_ptr<QuicData> message_data_;
+ std::unique_ptr<QuicData> message_data_;
QuicCryptoClientConfig crypto_config_;
CryptoTestUtils::FakeServerOptions server_options_;
};
@@ -193,7 +194,7 @@
server_config_update.SetValue(kSourceAddressTokenTag, stk);
server_config_update.SetValue(kSCFG, scfg);
- scoped_ptr<QuicData> data(
+ std::unique_ptr<QuicData> data(
CryptoFramer::ConstructHandshakeMessage(server_config_update));
stream()->OnStreamFrame(QuicStreamFrame(kCryptoStreamId, /*fin=*/false,
/*offset=*/0, data->AsStringPiece()));
@@ -213,7 +214,7 @@
CloseConnection(QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE, _, _));
CryptoHandshakeMessage server_config_update;
server_config_update.set_tag(kSCUP);
- scoped_ptr<QuicData> data(
+ std::unique_ptr<QuicData> data(
CryptoFramer::ConstructHandshakeMessage(server_config_update));
stream()->OnStreamFrame(QuicStreamFrame(kCryptoStreamId, /*fin=*/false,
/*offset=*/0, data->AsStringPiece()));
@@ -306,12 +307,12 @@
// Client crypto stream state
PacketSavingConnection* client_connection_;
- scoped_ptr<TestQuicSpdyClientSession> client_session_;
+ std::unique_ptr<TestQuicSpdyClientSession> client_session_;
QuicCryptoClientConfig client_crypto_config_;
// Server crypto stream state
PacketSavingConnection* server_connection_;
- scoped_ptr<TestQuicSpdyServerSession> server_session_;
+ std::unique_ptr<TestQuicSpdyServerSession> server_session_;
QuicCryptoServerConfig server_crypto_config_;
QuicCompressedCertsCache server_compressed_certs_cache_;
QuicServerId server_id_;
diff --git a/net/quic/quic_crypto_server_stream.cc b/net/quic/quic_crypto_server_stream.cc
index 7671c06f..cee73caa 100644
--- a/net/quic/quic_crypto_server_stream.cc
+++ b/net/quic/quic_crypto_server_stream.cc
@@ -289,7 +289,7 @@
}
const string& channel_id(crypto_negotiated_params_.channel_id);
- scoped_ptr<crypto::SecureHash> hash(
+ std::unique_ptr<crypto::SecureHash> hash(
crypto::SecureHash::Create(crypto::SecureHash::SHA256));
hash->Update(channel_id.data(), channel_id.size());
uint8_t digest[32];
diff --git a/net/quic/quic_crypto_server_stream.h b/net/quic/quic_crypto_server_stream.h
index b78e888..65e8f04c3 100644
--- a/net/quic/quic_crypto_server_stream.h
+++ b/net/quic/quic_crypto_server_stream.h
@@ -195,7 +195,7 @@
// If the client provides CachedNetworkParameters in the STK in the CHLO, then
// store here, and send back in future STKs if we have no better bandwidth
// estimate to send.
- scoped_ptr<CachedNetworkParameters> previous_cached_network_params_;
+ std::unique_ptr<CachedNetworkParameters> previous_cached_network_params_;
// Contains any source address tokens which were present in the CHLO.
SourceAddressTokens previous_source_address_tokens_;
diff --git a/net/quic/quic_crypto_server_stream_test.cc b/net/quic/quic_crypto_server_stream_test.cc
index da3eba0..b82e0c1 100644
--- a/net/quic/quic_crypto_server_stream_test.cc
+++ b/net/quic/quic_crypto_server_stream_test.cc
@@ -5,9 +5,9 @@
#include "net/quic/quic_crypto_server_stream.h"
#include <map>
+#include <memory>
#include <vector>
-#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
#include "net/quic/crypto/crypto_framer.h"
@@ -185,7 +185,7 @@
// Server state
PacketSavingConnection* server_connection_;
- scoped_ptr<TestQuicSpdyServerSession> server_session_;
+ std::unique_ptr<TestQuicSpdyServerSession> server_session_;
QuicCryptoServerConfig server_crypto_config_;
QuicCompressedCertsCache server_compressed_certs_cache_;
QuicServerId server_id_;
@@ -193,10 +193,10 @@
// Client state
PacketSavingConnection* client_connection_;
QuicCryptoClientConfig client_crypto_config_;
- scoped_ptr<TestQuicSpdyClientSession> client_session_;
+ std::unique_ptr<TestQuicSpdyClientSession> client_session_;
CryptoHandshakeMessage message_;
- scoped_ptr<QuicData> message_data_;
+ std::unique_ptr<QuicData> message_data_;
CryptoTestUtils::FakeClientOptions client_options_;
DelayedVerifyStrikeRegisterClient* strike_register_client_;
diff --git a/net/quic/quic_crypto_stream_test.cc b/net/quic/quic_crypto_stream_test.cc
index 69d09d2..e7cc92a 100644
--- a/net/quic/quic_crypto_stream_test.cc
+++ b/net/quic/quic_crypto_stream_test.cc
@@ -4,11 +4,11 @@
#include "net/quic/quic_crypto_stream.h"
+#include <memory>
#include <string>
#include <vector>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/quic/crypto/crypto_handshake.h"
#include "net/quic/crypto/crypto_protocol.h"
#include "net/quic/test_tools/crypto_test_utils.h"
@@ -64,7 +64,7 @@
MockQuicSpdySession session_;
MockQuicCryptoStream stream_;
CryptoHandshakeMessage message_;
- scoped_ptr<QuicData> message_data_;
+ std::unique_ptr<QuicData> message_data_;
private:
DISALLOW_COPY_AND_ASSIGN(QuicCryptoStreamTest);
diff --git a/net/quic/quic_data_writer_test.cc b/net/quic/quic_data_writer_test.cc
index b3d6e77..f3d2bbb 100644
--- a/net/quic/quic_data_writer_test.cc
+++ b/net/quic/quic_data_writer_test.cc
@@ -6,7 +6,8 @@
#include <stdint.h>
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
#include "net/quic/quic_data_reader.h"
#include "net/test/gtest_util.h"
#include "testing/gtest/include/gtest/gtest.h"
diff --git a/net/quic/quic_end_to_end_unittest.cc b/net/quic/quic_end_to_end_unittest.cc
index 7441c7f..612e48d6 100644
--- a/net/quic/quic_end_to_end_unittest.cc
+++ b/net/quic/quic_end_to_end_unittest.cc
@@ -2,12 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <memory>
#include <ostream>
#include <utility>
#include <vector>
#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "net/base/elements_upload_data_stream.h"
@@ -62,7 +63,7 @@
// HttpTransactionFactory methods
int CreateTransaction(RequestPriority priority,
- scoped_ptr<HttpTransaction>* trans) override {
+ std::unique_ptr<HttpTransaction>* trans) override {
trans->reset(new HttpNetworkTransaction(priority, session_.get()));
return OK;
}
@@ -72,7 +73,7 @@
HttpNetworkSession* GetSession() override { return session_.get(); };
private:
- scoped_ptr<HttpNetworkSession> session_;
+ std::unique_ptr<HttpNetworkSession> session_;
};
struct TestParams {
@@ -223,8 +224,8 @@
// Initializes |request_| for a post of |length| bytes.
void InitializePostRequest(size_t length) {
GenerateBody(length);
- std::vector<scoped_ptr<UploadElementReader>> element_readers;
- element_readers.push_back(make_scoped_ptr(new UploadBytesElementReader(
+ std::vector<std::unique_ptr<UploadElementReader>> element_readers;
+ element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
request_body_.data(), request_body_.length())));
upload_data_stream_.reset(
new ElementsUploadDataStream(std::move(element_readers), 0));
@@ -244,22 +245,22 @@
EXPECT_EQ(body, consumer.content());
}
- scoped_ptr<MockHostResolver> host_resolver_impl_;
+ std::unique_ptr<MockHostResolver> host_resolver_impl_;
MappedHostResolver host_resolver_;
MockCertVerifier cert_verifier_;
- scoped_ptr<ChannelIDService> channel_id_service_;
+ std::unique_ptr<ChannelIDService> channel_id_service_;
TransportSecurityState transport_security_state_;
- scoped_ptr<CTVerifier> cert_transparency_verifier_;
+ std::unique_ptr<CTVerifier> cert_transparency_verifier_;
scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
- scoped_ptr<ProxyService> proxy_service_;
- scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
+ std::unique_ptr<ProxyService> proxy_service_;
+ std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
HttpServerPropertiesImpl http_server_properties;
HttpNetworkSession::Params params_;
- scoped_ptr<TestTransactionFactory> transaction_factory_;
+ std::unique_ptr<TestTransactionFactory> transaction_factory_;
HttpRequestInfo request_;
std::string request_body_;
- scoped_ptr<UploadDataStream> upload_data_stream_;
- scoped_ptr<ServerThread> server_thread_;
+ std::unique_ptr<UploadDataStream> upload_data_stream_;
+ std::unique_ptr<ServerThread> server_thread_;
IPEndPoint server_address_;
std::string server_hostname_;
QuicConfig server_config_;
diff --git a/net/quic/quic_fec_group_test.cc b/net/quic/quic_fec_group_test.cc
index 5f5358d..50c4c55 100644
--- a/net/quic/quic_fec_group_test.cc
+++ b/net/quic/quic_fec_group_test.cc
@@ -5,10 +5,10 @@
#include "net/quic/quic_fec_group.h"
#include <algorithm>
+#include <memory>
#include <vector>
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "testing/gmock/include/gmock/gmock.h"
using ::testing::_;
@@ -46,7 +46,7 @@
// kData[] and kEntropyFlag[] are indexed by packet numbers, which
// start at 1.
DCHECK_GE(arraysize(kData), num_packets);
- scoped_ptr<char[]> redundancy(new char[kDataMaxLen]);
+ std::unique_ptr<char[]> redundancy(new char[kDataMaxLen]);
for (size_t i = 0; i < kDataMaxLen; i++) {
redundancy[i] = 0x00;
}
@@ -278,7 +278,7 @@
char* buffer_;
size_t size_;
- scoped_ptr<char[]> allocation_;
+ std::unique_ptr<char[]> allocation_;
};
MisalignedBuffer::MisalignedBuffer(const string& original, size_t offset) {
diff --git a/net/quic/quic_flow_controller_test.cc b/net/quic/quic_flow_controller_test.cc
index dbe7477..b189a408 100644
--- a/net/quic/quic_flow_controller_test.cc
+++ b/net/quic/quic_flow_controller_test.cc
@@ -41,7 +41,7 @@
QuicStreamId stream_id_;
QuicByteCount send_window_;
QuicByteCount receive_window_;
- scoped_ptr<QuicFlowController> flow_controller_;
+ std::unique_ptr<QuicFlowController> flow_controller_;
MockConnectionHelper helper_;
MockConnection connection_;
};
diff --git a/net/quic/quic_framer.cc b/net/quic/quic_framer.cc
index 3d3e36f2..da91cfc 100644
--- a/net/quic/quic_framer.cc
+++ b/net/quic/quic_framer.cc
@@ -436,7 +436,7 @@
size_t len =
kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + reset_serialized.length();
- scoped_ptr<char[]> buffer(new char[len]);
+ std::unique_ptr<char[]> buffer(new char[len]);
QuicDataWriter writer(len, buffer.get());
uint8_t flags = static_cast<uint8_t>(PACKET_PUBLIC_FLAGS_RST |
@@ -462,7 +462,7 @@
const QuicVersionVector& versions) {
DCHECK(!versions.empty());
size_t len = GetVersionNegotiationPacketSize(versions.size());
- scoped_ptr<char[]> buffer(new char[len]);
+ std::unique_ptr<char[]> buffer(new char[len]);
QuicDataWriter writer(len, buffer.get());
uint8_t flags = static_cast<uint8_t>(PACKET_PUBLIC_FLAGS_VERSION |
@@ -524,7 +524,7 @@
rv = ProcessDataPacket(&reader, public_header, packet, buffer,
kMaxPacketSize);
} else {
- scoped_ptr<char[]> large_buffer(new char[packet.length()]);
+ std::unique_ptr<char[]> large_buffer(new char[packet.length()]);
rv = ProcessDataPacket(&reader, public_header, packet, large_buffer.get(),
packet.length());
QUIC_BUG_IF(rv) << "QUIC should never successfully process packets larger"
@@ -604,7 +604,7 @@
const QuicPacketPublicHeader& public_header) {
QuicPublicResetPacket packet(public_header);
- scoped_ptr<CryptoHandshakeMessage> reset(
+ std::unique_ptr<CryptoHandshakeMessage> reset(
CryptoFramer::ParseMessage(reader->ReadRemainingPayload()));
if (!reset.get()) {
set_detailed_error("Unable to read reset message.");
diff --git a/net/quic/quic_framer.h b/net/quic/quic_framer.h
index a0a0db1..5960e613 100644
--- a/net/quic/quic_framer.h
+++ b/net/quic/quic_framer.h
@@ -8,6 +8,7 @@
#include <stddef.h>
#include <stdint.h>
+#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
@@ -15,7 +16,6 @@
#include "base/logging.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/quic/quic_protocol.h"
@@ -530,9 +530,9 @@
// skipped as necessary).
QuicVersionVector supported_versions_;
// Primary decrypter used to decrypt packets during parsing.
- scoped_ptr<QuicDecrypter> decrypter_;
+ std::unique_ptr<QuicDecrypter> decrypter_;
// Alternative decrypter that can also be used to decrypt packets.
- scoped_ptr<QuicDecrypter> alternative_decrypter_;
+ std::unique_ptr<QuicDecrypter> alternative_decrypter_;
// The encryption level of |decrypter_|.
EncryptionLevel decrypter_level_;
// The encryption level of |alternative_decrypter_|.
@@ -542,7 +542,7 @@
// decrypter.
bool alternative_decrypter_latch_;
// Encrypters used to encrypt packets via EncryptPayload().
- scoped_ptr<QuicEncrypter> encrypter_[NUM_ENCRYPTION_LEVELS];
+ std::unique_ptr<QuicEncrypter> encrypter_[NUM_ENCRYPTION_LEVELS];
// Tracks if the framer is being used by the entity that received the
// connection or the entity that initiated it.
Perspective perspective_;
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index 07ad276..16a2159d 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -5,13 +5,14 @@
#include "net/quic/quic_framer.h"
#include <stdint.h>
+
#include <algorithm>
#include <map>
+#include <memory>
#include <string>
#include <vector>
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "net/quic/crypto/quic_decrypter.h"
#include "net/quic/crypto/quic_encrypter.h"
@@ -311,10 +312,10 @@
bool accept_packet_;
bool accept_public_header_;
- scoped_ptr<QuicPacketHeader> header_;
- scoped_ptr<QuicPacketPublicHeader> public_header_;
- scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
- scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
+ std::unique_ptr<QuicPacketHeader> header_;
+ std::unique_ptr<QuicPacketPublicHeader> public_header_;
+ std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
+ std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
vector<QuicStreamFrame*> stream_frames_;
vector<QuicAckFrame*> ack_frames_;
vector<QuicStopWaitingFrame*> stop_waiting_frames_;
@@ -2535,7 +2536,7 @@
// Verify that the packet re-serializes identically.
QuicFrames frames;
frames.push_back(QuicFrame(frame));
- scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -2606,7 +2607,7 @@
// Verify that the packet re-serializes identically.
QuicFrames frames;
frames.push_back(QuicFrame(frame));
- scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -2675,7 +2676,7 @@
// Verify that the packet re-serializes identically.
QuicFrames frames;
frames.push_back(QuicFrame(frame));
- scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3372,7 +3373,7 @@
!kIncludePathId, PACKET_6BYTE_PACKET_NUMBER);
memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3419,7 +3420,7 @@
!kIncludePathId, PACKET_4BYTE_PACKET_NUMBER);
memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3466,7 +3467,7 @@
!kIncludePathId, PACKET_2BYTE_PACKET_NUMBER);
memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3513,7 +3514,7 @@
!kIncludePathId, PACKET_1BYTE_PACKET_NUMBER);
memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3564,7 +3565,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3613,7 +3614,7 @@
// clang-format on
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3668,7 +3669,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3726,7 +3727,7 @@
// clang-format on
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -3747,8 +3748,9 @@
// clang-format on
QuicConnectionId connection_id = kConnectionId;
- scoped_ptr<QuicEncryptedPacket> data(framer_.BuildVersionNegotiationPacket(
- connection_id, SupportedVersions(GetParam())));
+ std::unique_ptr<QuicEncryptedPacket> data(
+ framer_.BuildVersionNegotiationPacket(connection_id,
+ SupportedVersions(GetParam())));
test::CompareCharArraysWithHexError("constructed packet", data->data(),
data->length(), AsChars(packet),
arraysize(packet));
@@ -3837,7 +3839,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
if (framer_.version() <= QUIC_VERSION_31) {
@@ -4033,7 +4035,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
if (framer_.version() <= QUIC_VERSION_31) {
@@ -4134,7 +4136,7 @@
// clang-format on
if (framer_.version() <= QUIC_VERSION_31) {
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames, 37u));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames, 37u));
ASSERT_TRUE(data != nullptr);
// Expect 1 byte unused since at least 2 bytes are needed to fit more nacks.
EXPECT_EQ(36u, data->length());
@@ -4142,7 +4144,7 @@
data->length(), AsChars(packet),
arraysize(packet));
} else {
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames, 36u));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames, 36u));
ASSERT_TRUE(data != nullptr);
// Expect 1 byte unused since at least 2 bytes are needed to fit more nacks.
EXPECT_EQ(35u, data->length());
@@ -4191,7 +4193,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4242,7 +4244,7 @@
QuicFrames frames;
frames.push_back(QuicFrame(&rst_frame));
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4294,7 +4296,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4349,7 +4351,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4397,7 +4399,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4441,7 +4443,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4482,7 +4484,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4527,7 +4529,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4569,7 +4571,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -4613,7 +4615,7 @@
};
// clang-format on
- scoped_ptr<QuicEncryptedPacket> data(
+ std::unique_ptr<QuicEncryptedPacket> data(
framer_.BuildPublicResetPacket(reset_packet));
ASSERT_TRUE(data != nullptr);
@@ -4667,7 +4669,7 @@
};
// clang-format on
- scoped_ptr<QuicEncryptedPacket> data(
+ std::unique_ptr<QuicEncryptedPacket> data(
framer_.BuildPublicResetPacket(reset_packet));
ASSERT_TRUE(data != nullptr);
@@ -4699,7 +4701,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> raw(new QuicPacket(
+ std::unique_ptr<QuicPacket> raw(new QuicPacket(
AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
!kIncludeVersion, !kIncludePathId, PACKET_6BYTE_PACKET_NUMBER));
char buffer[kMaxPacketSize];
@@ -4736,7 +4738,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> raw(new QuicPacket(
+ std::unique_ptr<QuicPacket> raw(new QuicPacket(
AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
kIncludeVersion, !kIncludePathId, PACKET_6BYTE_PACKET_NUMBER));
char buffer[kMaxPacketSize];
@@ -4773,7 +4775,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> raw(new QuicPacket(
+ std::unique_ptr<QuicPacket> raw(new QuicPacket(
AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
!kIncludeVersion, kIncludePathId, PACKET_6BYTE_PACKET_NUMBER));
char buffer[kMaxPacketSize];
@@ -4811,7 +4813,7 @@
};
// clang-format on
- scoped_ptr<QuicPacket> raw(new QuicPacket(
+ std::unique_ptr<QuicPacket> raw(new QuicPacket(
AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
kIncludeVersion, kIncludePathId, PACKET_6BYTE_PACKET_NUMBER));
char buffer[kMaxPacketSize];
@@ -4841,7 +4843,7 @@
frames.push_back(frame);
// Build an ack packet with truncation due to limit in number of nack ranges.
- scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
ASSERT_TRUE(raw_ack_packet != nullptr);
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
@@ -4879,7 +4881,8 @@
frames.push_back(frame);
// Build an ack packet with truncation due to limit in number of nack ranges.
- scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames, 500));
+ std::unique_ptr<QuicPacket> raw_ack_packet(
+ BuildDataPacket(header, frames, 500));
ASSERT_TRUE(raw_ack_packet != nullptr);
char buffer[kMaxPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
@@ -4919,7 +4922,7 @@
QuicFrames frames;
frames.push_back(frame);
- scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
+ std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
ASSERT_TRUE(raw_ack_packet != nullptr);
char buffer[kMaxPacketSize];
@@ -5065,7 +5068,7 @@
framer_.SetDecrypter(ENCRYPTION_NONE, QuicDecrypter::Create(kNULL));
framer_.SetEncrypter(ENCRYPTION_NONE, QuicEncrypter::Create(kNULL));
- scoped_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
+ std::unique_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
42, false, false, false, kDefaultPathId, kTestQuicStreamId, kTestString,
PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER));
@@ -5098,7 +5101,7 @@
framer_.SetDecrypter(ENCRYPTION_NONE, QuicDecrypter::Create(kNULL));
framer_.SetEncrypter(ENCRYPTION_NONE, QuicEncrypter::Create(kNULL));
- scoped_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
+ std::unique_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
42, false, false, false, kDefaultPathId, kTestQuicStreamId, kTestString,
PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, nullptr));
diff --git a/net/quic/quic_headers_stream.h b/net/quic/quic_headers_stream.h
index ba95180..e216794 100644
--- a/net/quic/quic_headers_stream.h
+++ b/net/quic/quic_headers_stream.h
@@ -7,8 +7,9 @@
#include <stddef.h>
+#include <memory>
+
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
#include "net/quic/quic_header_list.h"
#include "net/quic/quic_protocol.h"
@@ -112,7 +113,7 @@
QuicTime prev_max_timestamp_;
SpdyFramer spdy_framer_;
- scoped_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
+ std::unique_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
// Either empty, or contains the complete list of headers.
QuicHeaderList header_list_;
diff --git a/net/quic/quic_http_stream.cc b/net/quic/quic_http_stream.cc
index 591f3ce..f31e2d0 100644
--- a/net/quic/quic_http_stream.cc
+++ b/net/quic/quic_http_stream.cc
@@ -29,11 +29,11 @@
namespace {
-scoped_ptr<base::Value> NetLogQuicPushStreamCallback(
+std::unique_ptr<base::Value> NetLogQuicPushStreamCallback(
QuicStreamId stream_id,
const GURL* url,
NetLogCaptureMode capture_mode) {
- scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+ std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("stream_id", stream_id);
dict->SetString("url", url->spec());
return std::move(dict);
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index afd0f95..4774365 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -6,9 +6,10 @@
#include <stdint.h>
+#include <memory>
#include <vector>
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/thread_task_runner_handle.h"
#include "net/base/chunked_upload_data_stream.h"
@@ -162,7 +163,7 @@
}
// Adds a packet to the list of expected writes.
- void AddWrite(scoped_ptr<QuicReceivedPacket> packet) {
+ void AddWrite(std::unique_ptr<QuicReceivedPacket> packet) {
writes_.push_back(PacketToWrite(SYNCHRONOUS, packet.release()));
}
@@ -178,7 +179,7 @@
socket_data_->AllWriteDataConsumed();
}
- void ProcessPacket(scoped_ptr<QuicReceivedPacket> packet) {
+ void ProcessPacket(std::unique_ptr<QuicReceivedPacket> packet) {
connection_->ProcessUdpPacket(self_addr_, peer_addr_, *packet);
}
@@ -197,7 +198,7 @@
socket_data_.reset(new StaticSocketDataProvider(
nullptr, 0, mock_writes_.get(), writes_.size()));
- scoped_ptr<MockUDPClientSocket> socket(new MockUDPClientSocket(
+ std::unique_ptr<MockUDPClientSocket> socket(new MockUDPClientSocket(
socket_data_.get(), net_log_.bound().net_log()));
socket->Connect(peer_addr_);
runner_ = new TestTaskRunner(&clock_);
@@ -238,7 +239,7 @@
connection_, std::move(socket),
/*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
&transport_security_state_,
- make_scoped_ptr(static_cast<QuicServerInfo*>(nullptr)),
+ base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
QuicServerId(kDefaultServerHostName, kDefaultServerPort,
PRIVACY_MODE_DISABLED),
kQuicYieldAfterPacketsRead,
@@ -285,7 +286,7 @@
response_data_ = body;
}
- scoped_ptr<QuicReceivedPacket> InnerConstructDataPacket(
+ std::unique_ptr<QuicReceivedPacket> InnerConstructDataPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -296,7 +297,7 @@
should_include_version, fin, offset, data);
}
- scoped_ptr<QuicReceivedPacket> ConstructDataPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructDataPacket(
QuicPacketNumber packet_number,
bool should_include_version,
bool fin,
@@ -306,7 +307,7 @@
should_include_version, fin, offset, data);
}
- scoped_ptr<QuicReceivedPacket> InnerConstructRequestHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> InnerConstructRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -320,7 +321,7 @@
request_headers_, spdy_headers_frame_length);
}
- scoped_ptr<QuicReceivedPacket> ConstructRequestHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructRequestHeadersPacket(
QuicPacketNumber packet_number,
bool fin,
RequestPriority request_priority,
@@ -330,7 +331,7 @@
spdy_headers_frame_length);
}
- scoped_ptr<QuicReceivedPacket> InnerConstructResponseHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> InnerConstructResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool fin,
@@ -340,7 +341,7 @@
spdy_headers_frame_length, &response_offset_);
}
- scoped_ptr<QuicReceivedPacket> ConstructResponseHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructResponseHeadersPacket(
QuicPacketNumber packet_number,
bool fin,
size_t* spdy_headers_frame_length) {
@@ -348,7 +349,7 @@
spdy_headers_frame_length);
}
- scoped_ptr<QuicReceivedPacket> ConstructResponseHeadersPacketWithOffset(
+ std::unique_ptr<QuicReceivedPacket> ConstructResponseHeadersPacketWithOffset(
QuicPacketNumber packet_number,
bool fin,
size_t* spdy_headers_frame_length,
@@ -358,7 +359,7 @@
spdy_headers_frame_length, offset);
}
- scoped_ptr<QuicReceivedPacket> ConstructResponseTrailersPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructResponseTrailersPacket(
QuicPacketNumber packet_number,
bool fin,
const SpdyHeaderBlock& trailers,
@@ -369,26 +370,26 @@
spdy_headers_frame_length, offset);
}
- scoped_ptr<QuicReceivedPacket> ConstructRstStreamPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructRstStreamPacket(
QuicPacketNumber packet_number) {
return maker_.MakeRstPacket(
packet_number, true, stream_id_,
AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
}
- scoped_ptr<QuicReceivedPacket> ConstructRstStreamCancelledPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructRstStreamCancelledPacket(
QuicPacketNumber packet_number) {
return maker_.MakeRstPacket(packet_number, !kIncludeVersion, stream_id_,
QUIC_STREAM_CANCELLED);
}
- scoped_ptr<QuicReceivedPacket> ConstructRstStreamVaryMismatchPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructRstStreamVaryMismatchPacket(
QuicPacketNumber packet_number) {
return maker_.MakeRstPacket(packet_number, !kIncludeVersion, promise_id_,
QUIC_PROMISE_VARY_MISMATCH);
}
- scoped_ptr<QuicReceivedPacket> ConstructAckAndRstStreamPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructAckAndRstStreamPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber ack_least_unacked,
@@ -399,12 +400,12 @@
!kIncludeCongestionFeedback);
}
- scoped_ptr<QuicReceivedPacket> ConstructAckAndRstStreamPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructAckAndRstStreamPacket(
QuicPacketNumber packet_number) {
return ConstructAckAndRstStreamPacket(packet_number, 2, 1, 1);
}
- scoped_ptr<QuicReceivedPacket> ConstructAckPacket(
+ std::unique_ptr<QuicReceivedPacket> ConstructAckPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber least_unacked) {
@@ -424,14 +425,14 @@
bool use_closing_stream_;
MockSendAlgorithm* send_algorithm_;
scoped_refptr<TestTaskRunner> runner_;
- scoped_ptr<MockWrite[]> mock_writes_;
+ std::unique_ptr<MockWrite[]> mock_writes_;
MockClock clock_;
TestQuicConnection* connection_;
- scoped_ptr<QuicChromiumConnectionHelper> helper_;
+ std::unique_ptr<QuicChromiumConnectionHelper> helper_;
testing::StrictMock<MockConnectionVisitor> visitor_;
- scoped_ptr<QuicHttpStream> stream_;
+ std::unique_ptr<QuicHttpStream> stream_;
TransportSecurityState transport_security_state_;
- scoped_ptr<QuicChromiumClientSession> session_;
+ std::unique_ptr<QuicChromiumClientSession> session_;
QuicCryptoClientConfig crypto_config_;
TestCompletionCallback callback_;
HttpRequestInfo request_;
@@ -445,7 +446,7 @@
QuicClientPushPromiseIndex push_promise_index_;
// For server push testing
- scoped_ptr<QuicHttpStream> promised_stream_;
+ std::unique_ptr<QuicHttpStream> promised_stream_;
SpdyHeaderBlock push_promise_;
SpdyHeaderBlock promised_response_;
const QuicStreamId promise_id_;
@@ -461,7 +462,7 @@
MockRandom random_generator_;
ProofVerifyDetailsChromium verify_details_;
MockCryptoClientStreamFactory crypto_client_stream_factory_;
- scoped_ptr<StaticSocketDataProvider> socket_data_;
+ std::unique_ptr<StaticSocketDataProvider> socket_data_;
std::vector<PacketToWrite> writes_;
QuicStreamOffset response_offset_;
};
@@ -840,8 +841,8 @@
Initialize();
- std::vector<scoped_ptr<UploadElementReader>> element_readers;
- element_readers.push_back(make_scoped_ptr(
+ std::vector<std::unique_ptr<UploadElementReader>> element_readers;
+ element_readers.push_back(base::WrapUnique(
new UploadBytesElementReader(kUploadData, strlen(kUploadData))));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
request_.method = "POST";
diff --git a/net/quic/quic_http_utils.cc b/net/quic/quic_http_utils.cc
index 6091c08..c6dd505 100644
--- a/net/quic/quic_http_utils.cc
+++ b/net/quic/quic_http_utils.cc
@@ -22,13 +22,14 @@
: static_cast<RequestPriority>(HIGHEST - priority);
}
-scoped_ptr<base::Value> QuicRequestNetLogCallback(
+std::unique_ptr<base::Value> QuicRequestNetLogCallback(
QuicStreamId stream_id,
const SpdyHeaderBlock* headers,
SpdyPriority priority,
NetLogCaptureMode capture_mode) {
- scoped_ptr<base::DictionaryValue> dict(static_cast<base::DictionaryValue*>(
- SpdyHeaderBlockNetLogCallback(headers, capture_mode).release()));
+ std::unique_ptr<base::DictionaryValue> dict(
+ static_cast<base::DictionaryValue*>(
+ SpdyHeaderBlockNetLogCallback(headers, capture_mode).release()));
dict->SetInteger("quic_priority", static_cast<int>(priority));
dict->SetInteger("quic_stream_id", static_cast<int>(stream_id));
return std::move(dict);
diff --git a/net/quic/quic_http_utils.h b/net/quic/quic_http_utils.h
index 1bde98a..ce5dd2f 100644
--- a/net/quic/quic_http_utils.h
+++ b/net/quic/quic_http_utils.h
@@ -21,7 +21,7 @@
ConvertQuicPriorityToRequestPriority(SpdyPriority priority);
// Converts a SpdyHeaderBlock and priority into NetLog event parameters.
-NET_EXPORT scoped_ptr<base::Value> QuicRequestNetLogCallback(
+NET_EXPORT std::unique_ptr<base::Value> QuicRequestNetLogCallback(
QuicStreamId stream_id,
const SpdyHeaderBlock* headers,
SpdyPriority priority,
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index 4774b5bf..f937857 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -2,11 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <memory>
#include <vector>
#include "base/compiler_specific.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/run_loop.h"
#include "base/stl_util.h"
#include "base/strings/stringprintf.h"
@@ -84,13 +84,13 @@
~MockQuicData() { STLDeleteElements(&packets_); }
- void AddSynchronousRead(scoped_ptr<QuicEncryptedPacket> packet) {
+ void AddSynchronousRead(std::unique_ptr<QuicEncryptedPacket> packet) {
reads_.push_back(MockRead(SYNCHRONOUS, packet->data(), packet->length(),
packet_number_++));
packets_.push_back(packet.release());
}
- void AddRead(scoped_ptr<QuicEncryptedPacket> packet) {
+ void AddRead(std::unique_ptr<QuicEncryptedPacket> packet) {
reads_.push_back(
MockRead(ASYNC, packet->data(), packet->length(), packet_number_++));
packets_.push_back(packet.release());
@@ -100,7 +100,7 @@
reads_.push_back(MockRead(mode, rv, packet_number_++));
}
- void AddWrite(scoped_ptr<QuicEncryptedPacket> packet) {
+ void AddWrite(std::unique_ptr<QuicEncryptedPacket> packet) {
writes_.push_back(MockWrite(SYNCHRONOUS, packet->data(), packet->length(),
packet_number_++));
packets_.push_back(packet.release());
@@ -121,7 +121,7 @@
std::vector<MockWrite> writes_;
std::vector<MockRead> reads_;
size_t packet_number_;
- scoped_ptr<SequencedSocketData> socket_data_;
+ std::unique_ptr<SequencedSocketData> socket_data_;
};
class ProxyHeadersHandler {
@@ -167,13 +167,13 @@
~TestSocketPerformanceWatcherFactory() override {}
// SocketPerformanceWatcherFactory implementation:
- scoped_ptr<SocketPerformanceWatcher> CreateSocketPerformanceWatcher(
+ std::unique_ptr<SocketPerformanceWatcher> CreateSocketPerformanceWatcher(
const Protocol protocol) override {
if (protocol != PROTOCOL_QUIC) {
return nullptr;
}
++watcher_count_;
- return scoped_ptr<SocketPerformanceWatcher>(
+ return std::unique_ptr<SocketPerformanceWatcher>(
new TestSocketPerformanceWatcher(&rtt_notification_received_));
}
@@ -233,26 +233,26 @@
base::MessageLoop::current()->RunUntilIdle();
}
- scoped_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket(
QuicPacketNumber num) {
return maker_.MakeConnectionClosePacket(num);
}
- scoped_ptr<QuicEncryptedPacket> ConstructGoAwayPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructGoAwayPacket(
QuicPacketNumber num,
QuicErrorCode error_code,
std::string reason_phrase) {
return maker_.MakeGoAwayPacket(num, error_code, reason_phrase);
}
- scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructAckPacket(
QuicPacketNumber largest_received,
QuicPacketNumber least_unacked) {
return maker_.MakeAckPacket(2, largest_received, least_unacked,
least_unacked, true);
}
- scoped_ptr<QuicEncryptedPacket> ConstructAckAndRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructAckAndRstPacket(
QuicPacketNumber num,
QuicStreamId stream_id,
QuicRstStreamErrorCode error_code,
@@ -264,7 +264,7 @@
stop_least_unacked, true);
}
- scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructAckPacket(
QuicPacketNumber largest_received,
QuicPacketNumber least_unacked,
QuicTestPacketMaker* maker) {
@@ -272,7 +272,7 @@
least_unacked, true);
}
- scoped_ptr<QuicEncryptedPacket> ConstructAckAndConnectionClosePacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructAckAndConnectionClosePacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber ack_least_unacked,
@@ -281,7 +281,7 @@
ack_least_unacked, stop_least_unacked, true);
}
- scoped_ptr<QuicEncryptedPacket> ConstructAckAndConnectionClosePacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructAckAndConnectionClosePacket(
QuicPacketNumber num,
QuicTime::Delta delta_time_largest_observed,
QuicPacketNumber largest_received,
@@ -293,7 +293,7 @@
least_unacked, quic_error, quic_error_details);
}
- scoped_ptr<QuicEncryptedPacket> ConstructRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructRstPacket(
QuicPacketNumber num,
bool include_version,
QuicStreamId stream_id,
@@ -326,7 +326,7 @@
return maker_.GetResponseHeaders(status, alt_svc);
}
- scoped_ptr<QuicEncryptedPacket> ConstructDataPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructDataPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -337,7 +337,7 @@
should_include_version, fin, offset, data);
}
- scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -351,7 +351,7 @@
headers, offset);
}
- scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -366,7 +366,7 @@
headers, offset);
}
- scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -376,7 +376,7 @@
should_include_version, fin, headers,
nullptr, &maker_);
}
- scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -388,7 +388,7 @@
nullptr, maker);
}
- scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -399,7 +399,7 @@
nullptr, &maker_);
}
- scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -411,7 +411,7 @@
nullptr, maker);
}
- scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -422,7 +422,7 @@
packet_number, stream_id, should_include_version, fin, headers, offset);
}
- scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -466,7 +466,8 @@
session_->quic_stream_factory()->socket_receive_buffer_size());
}
- void CheckWasQuicResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
+ void CheckWasQuicResponse(
+ const std::unique_ptr<HttpNetworkTransaction>& trans) {
const HttpResponseInfo* response = trans->GetResponseInfo();
ASSERT_TRUE(response != nullptr);
ASSERT_TRUE(response->headers.get() != nullptr);
@@ -477,14 +478,15 @@
response->connection_info);
}
- void CheckResponsePort(const scoped_ptr<HttpNetworkTransaction>& trans,
+ void CheckResponsePort(const std::unique_ptr<HttpNetworkTransaction>& trans,
uint16_t port) {
const HttpResponseInfo* response = trans->GetResponseInfo();
ASSERT_TRUE(response != nullptr);
EXPECT_EQ(port, response->socket_address.port());
}
- void CheckWasHttpResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
+ void CheckWasHttpResponse(
+ const std::unique_ptr<HttpNetworkTransaction>& trans) {
const HttpResponseInfo* response = trans->GetResponseInfo();
ASSERT_TRUE(response != nullptr);
ASSERT_TRUE(response->headers.get() != nullptr);
@@ -495,14 +497,14 @@
response->connection_info);
}
- void CheckResponseData(const scoped_ptr<HttpNetworkTransaction>& trans,
+ void CheckResponseData(const std::unique_ptr<HttpNetworkTransaction>& trans,
const std::string& expected) {
std::string response_data;
ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
EXPECT_EQ(expected, response_data);
}
- void RunTransaction(const scoped_ptr<HttpNetworkTransaction>& trans) {
+ void RunTransaction(const std::unique_ptr<HttpNetworkTransaction>& trans) {
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -510,7 +512,7 @@
}
void SendRequestAndExpectHttpResponse(const std::string& expected) {
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
RunTransaction(trans);
CheckWasHttpResponse(trans);
@@ -572,7 +574,7 @@
}
void AddHangingNonAlternateProtocolSocketData() {
- scoped_ptr<StaticSocketDataProvider> hanging_data;
+ std::unique_ptr<StaticSocketDataProvider> hanging_data;
hanging_data.reset(new StaticSocketDataProvider());
MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
hanging_data->set_connect_data(hanging_connect);
@@ -583,24 +585,24 @@
MockClock* clock_; // Owned by QuicStreamFactory after CreateSession.
QuicTestPacketMaker maker_;
- scoped_ptr<HttpNetworkSession> session_;
+ std::unique_ptr<HttpNetworkSession> session_;
MockClientSocketFactory socket_factory_;
ProofVerifyDetailsChromium verify_details_;
MockCryptoClientStreamFactory crypto_client_stream_factory_;
MockHostResolver host_resolver_;
MockCertVerifier cert_verifier_;
TransportSecurityState transport_security_state_;
- scoped_ptr<CTVerifier> cert_transparency_verifier_;
+ std::unique_ptr<CTVerifier> cert_transparency_verifier_;
TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_;
scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
- scoped_ptr<ProxyService> proxy_service_;
- scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
+ std::unique_ptr<ProxyService> proxy_service_;
+ std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
MockRandom random_generator_;
HttpServerPropertiesImpl http_server_properties_;
HttpNetworkSession::Params params_;
HttpRequestInfo request_;
BoundTestNetLog net_log_;
- std::vector<scoped_ptr<StaticSocketDataProvider>> hanging_data_;
+ std::vector<std::unique_ptr<StaticSocketDataProvider>> hanging_data_;
SSLSocketDataProvider ssl_data_;
private:
@@ -608,7 +610,7 @@
const std::string& expected,
bool used_proxy,
uint16_t port) {
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
ProxyHeadersHandler proxy_headers_handler;
trans->SetBeforeProxyHeadersSentCallback(
@@ -839,7 +841,7 @@
EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count());
for (size_t i = 0; i < 2; ++i) {
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
@@ -1018,7 +1020,7 @@
session_->quic_stream_factory()->set_require_confirmation(true);
AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
@@ -1756,7 +1758,7 @@
base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
session_->http_server_properties()->SetAlternativeService(
origin, alternative_service, expiration);
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
@@ -1964,7 +1966,7 @@
session_->quic_stream_factory()->set_require_confirmation(true);
AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
@@ -2010,7 +2012,7 @@
session_->quic_stream_factory()->set_require_confirmation(true);
AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
@@ -2065,7 +2067,7 @@
session_->quic_stream_factory()->set_require_confirmation(true);
AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
@@ -2083,7 +2085,7 @@
TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
// Alternate-protocol job
- scoped_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1));
+ std::unique_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1));
MockRead quic_reads[] = {
MockRead(ASYNC, close->data(), close->length()),
MockRead(ASYNC, ERR_IO_PENDING), // No more data to read
@@ -2160,7 +2162,7 @@
CreateSession();
AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
@@ -2344,7 +2346,7 @@
request_.upload_data_stream = &upload_data;
- scoped_ptr<HttpNetworkTransaction> trans(
+ std::unique_ptr<HttpNetworkTransaction> trans(
new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
TestCompletionCallback callback;
int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
diff --git a/net/quic/quic_packet_creator.h b/net/quic/quic_packet_creator.h
index f74244f..b279d51 100644
--- a/net/quic/quic_packet_creator.h
+++ b/net/quic/quic_packet_creator.h
@@ -12,13 +12,13 @@
#include <stddef.h>
+#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/quic/quic_framer.h"
#include "net/quic/quic_protocol.h"
@@ -267,7 +267,7 @@
DebugDelegate* debug_delegate_;
QuicFramer* framer_;
- scoped_ptr<QuicRandomBoolSource> random_bool_source_;
+ std::unique_ptr<QuicRandomBoolSource> random_bool_source_;
QuicBufferAllocator* const buffer_allocator_;
// Controls whether version should be included while serializing the packet.
diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc
index fc649ba..a3e3c2a1 100644
--- a/net/quic/quic_packet_creator_test.cc
+++ b/net/quic/quic_packet_creator_test.cc
@@ -719,7 +719,7 @@
QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
QuicVersionVector versions;
versions.push_back(test::QuicVersionMax());
- scoped_ptr<QuicEncryptedPacket> encrypted(
+ std::unique_ptr<QuicEncryptedPacket> encrypted(
creator_.SerializeVersionNegotiationPacket(versions));
{
diff --git a/net/quic/quic_packet_generator_test.cc b/net/quic/quic_packet_generator_test.cc
index 0adbfe9..d913672 100644
--- a/net/quic/quic_packet_generator_test.cc
+++ b/net/quic/quic_packet_generator_test.cc
@@ -216,7 +216,7 @@
QuicAckFrame ack_frame_;
private:
- scoped_ptr<char[]> data_array_;
+ std::unique_ptr<char[]> data_array_;
struct iovec iov_;
};
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 44bcbac..d39e36da 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -11,6 +11,7 @@
#include <limits>
#include <list>
#include <map>
+#include <memory>
#include <ostream>
#include <set>
#include <string>
@@ -20,7 +21,6 @@
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/int128.h"
#include "net/base/iovec.h"
diff --git a/net/quic/quic_sent_packet_manager.h b/net/quic/quic_sent_packet_manager.h
index 6d4241e..7fa3743 100644
--- a/net/quic/quic_sent_packet_manager.h
+++ b/net/quic/quic_sent_packet_manager.h
@@ -8,12 +8,12 @@
#include <stddef.h>
#include <map>
+#include <memory>
#include <set>
#include <utility>
#include <vector>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/linked_hash_map.h"
#include "net/quic/congestion_control/loss_detection_interface.h"
#include "net/quic/congestion_control/rtt_stats.h"
@@ -404,8 +404,8 @@
NetworkChangeVisitor* network_change_visitor_;
const QuicPacketCount initial_congestion_window_;
RttStats rtt_stats_;
- scoped_ptr<SendAlgorithmInterface> send_algorithm_;
- scoped_ptr<LossDetectionInterface> loss_algorithm_;
+ std::unique_ptr<SendAlgorithmInterface> send_algorithm_;
+ std::unique_ptr<LossDetectionInterface> loss_algorithm_;
bool n_connection_simulation_;
// Receiver side buffer in bytes.
diff --git a/net/quic/quic_sent_packet_manager_test.cc b/net/quic/quic_sent_packet_manager_test.cc
index 5098261..7465e56 100644
--- a/net/quic/quic_sent_packet_manager_test.cc
+++ b/net/quic/quic_sent_packet_manager_test.cc
@@ -260,7 +260,7 @@
MockClock clock_;
QuicConnectionStats stats_;
MockSendAlgorithm* send_algorithm_;
- scoped_ptr<MockNetworkChangeVisitor> network_change_visitor_;
+ std::unique_ptr<MockNetworkChangeVisitor> network_change_visitor_;
bool saved_FLAGS_quic_disable_pacing_;
};
diff --git a/net/quic/quic_session.h b/net/quic/quic_session.h
index fd13d5ee..148b8f7 100644
--- a/net/quic/quic_session.h
+++ b/net/quic/quic_session.h
@@ -10,6 +10,7 @@
#include <stddef.h>
#include <map>
+#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
@@ -17,7 +18,6 @@
#include "base/compiler_specific.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/ip_endpoint.h"
#include "net/quic/quic_connection.h"
@@ -340,7 +340,7 @@
std::map<QuicStreamId, QuicStreamOffset>
locally_closed_streams_highest_offset_;
- scoped_ptr<QuicConnection> connection_;
+ std::unique_ptr<QuicConnection> connection_;
std::vector<ReliableQuicStream*> closed_streams_;
diff --git a/net/quic/quic_spdy_session.h b/net/quic/quic_spdy_session.h
index e63fc08..f3a164e 100644
--- a/net/quic/quic_spdy_session.h
+++ b/net/quic/quic_spdy_session.h
@@ -117,7 +117,7 @@
private:
friend class test::QuicSpdySessionPeer;
- scoped_ptr<QuicHeadersStream> headers_stream_;
+ std::unique_ptr<QuicHeadersStream> headers_stream_;
DISALLOW_COPY_AND_ASSIGN(QuicSpdySession);
};
diff --git a/net/quic/quic_spdy_stream_test.cc b/net/quic/quic_spdy_stream_test.cc
index 3338175c..d01a2cd2 100644
--- a/net/quic/quic_spdy_stream_test.cc
+++ b/net/quic/quic_spdy_stream_test.cc
@@ -110,7 +110,7 @@
protected:
MockConnectionHelper helper_;
MockConnection* connection_;
- scoped_ptr<MockQuicSpdySession> session_;
+ std::unique_ptr<MockQuicSpdySession> session_;
// Owned by the |session_|.
TestStream* stream_;
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index 8db6c69..ee04541e 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -10,6 +10,7 @@
#include "base/location.h"
#include "base/macros.h"
+#include "base/memory/ptr_util.h"
#include "base/metrics/field_trial.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/sparse_histogram.h"
@@ -196,7 +197,7 @@
bool server_and_origin_have_same_host_;
bool is_post_;
bool was_alternative_service_recently_broken_;
- scoped_ptr<QuicServerInfo> server_info_;
+ std::unique_ptr<QuicServerInfo> server_info_;
bool started_another_job_;
const BoundNetLog net_log_;
int num_sent_client_hellos_;
@@ -554,17 +555,17 @@
QuicServerId(host_port_pair_, privacy_mode_));
}
-scoped_ptr<QuicHttpStream> QuicStreamRequest::CreateStream() {
+std::unique_ptr<QuicHttpStream> QuicStreamRequest::CreateStream() {
if (!session_)
return nullptr;
- return make_scoped_ptr(new QuicHttpStream(session_));
+ return base::WrapUnique(new QuicHttpStream(session_));
}
-scoped_ptr<BidirectionalStreamImpl>
+std::unique_ptr<BidirectionalStreamImpl>
QuicStreamRequest::CreateBidirectionalStreamImpl() {
if (!session_)
return nullptr;
- return make_scoped_ptr(new BidirectionalStreamQuicImpl(session_));
+ return base::WrapUnique(new BidirectionalStreamQuicImpl(session_));
}
QuicStreamFactory::QuicStreamFactory(
@@ -843,7 +844,7 @@
}
bool server_and_origin_have_same_host = host_port_pair.host() == url.host();
- scoped_ptr<Job> job(
+ std::unique_ptr<Job> job(
new Job(this, host_resolver_, server_id, server_and_origin_have_same_host,
WasQuicRecentlyBroken(server_id), cert_verify_flags,
method == "POST" /* is_post */, quic_server_info, net_log));
@@ -971,9 +972,10 @@
job_requests_map_.erase(server_id);
}
-scoped_ptr<QuicHttpStream> QuicStreamFactory::CreateFromSession(
+std::unique_ptr<QuicHttpStream> QuicStreamFactory::CreateFromSession(
QuicChromiumClientSession* session) {
- return scoped_ptr<QuicHttpStream>(new QuicHttpStream(session->GetWeakPtr()));
+ return std::unique_ptr<QuicHttpStream>(
+ new QuicHttpStream(session->GetWeakPtr()));
}
QuicChromiumClientSession::QuicDisabledReason
@@ -1248,9 +1250,9 @@
DCHECK(all_sessions_.empty());
}
-scoped_ptr<base::Value> QuicStreamFactory::QuicStreamFactoryInfoToValue()
+std::unique_ptr<base::Value> QuicStreamFactory::QuicStreamFactoryInfoToValue()
const {
- scoped_ptr<base::ListValue> list(new base::ListValue());
+ std::unique_ptr<base::ListValue> list(new base::ListValue());
for (SessionMap::const_iterator it = active_sessions_.begin();
it != active_sessions_.end(); ++it) {
@@ -1395,7 +1397,7 @@
// Use OS-specified port for socket (DEFAULT_BIND) instead of
// using the PortSuggester since the connection is being migrated
// and not being newly created.
- scoped_ptr<DatagramClientSocket> socket(
+ std::unique_ptr<DatagramClientSocket> socket(
client_socket_factory_->CreateDatagramClientSocket(
DatagramSocket::DEFAULT_BIND, RandIntCallback(),
session->net_log().net_log(), session->net_log().source()));
@@ -1406,10 +1408,11 @@
HistogramMigrationStatus(MIGRATION_STATUS_INTERNAL_ERROR);
return;
}
- scoped_ptr<QuicChromiumPacketReader> new_reader(new QuicChromiumPacketReader(
- socket.get(), clock_.get(), session, yield_after_packets_,
- yield_after_duration_, session->net_log()));
- scoped_ptr<QuicPacketWriter> new_writer(
+ std::unique_ptr<QuicChromiumPacketReader> new_reader(
+ new QuicChromiumPacketReader(socket.get(), clock_.get(), session,
+ yield_after_packets_, yield_after_duration_,
+ session->net_log()));
+ std::unique_ptr<QuicPacketWriter> new_writer(
new QuicChromiumPacketWriter(socket.get()));
if (!session->MigrateToSocket(std::move(socket), std::move(new_reader),
@@ -1508,13 +1511,14 @@
return OK;
}
-int QuicStreamFactory::CreateSession(const QuicServerId& server_id,
- int cert_verify_flags,
- scoped_ptr<QuicServerInfo> server_info,
- const AddressList& address_list,
- base::TimeTicks dns_resolution_end_time,
- const BoundNetLog& net_log,
- QuicChromiumClientSession** session) {
+int QuicStreamFactory::CreateSession(
+ const QuicServerId& server_id,
+ int cert_verify_flags,
+ std::unique_ptr<QuicServerInfo> server_info,
+ const AddressList& address_list,
+ base::TimeTicks dns_resolution_end_time,
+ const BoundNetLog& net_log,
+ QuicChromiumClientSession** session) {
TRACE_EVENT0("net", "QuicStreamFactory::CreateSession");
IPEndPoint addr = *address_list.begin();
bool enable_port_selection = enable_port_selection_;
@@ -1532,7 +1536,7 @@
: // Use our callback.
DatagramSocket::DEFAULT_BIND; // Use OS to randomize.
- scoped_ptr<DatagramClientSocket> socket(
+ std::unique_ptr<DatagramClientSocket> socket(
client_socket_factory_->CreateDatagramClientSocket(
bind_type, base::Bind(&PortSuggester::SuggestPort, port_suggester),
net_log.net_log(), net_log.source()));
@@ -1588,7 +1592,7 @@
// Use the factory to create a new socket performance watcher, and pass the
// ownership to QuicChromiumClientSession.
- scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher;
+ std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher;
if (socket_performance_watcher_factory_) {
socket_performance_watcher =
socket_performance_watcher_factory_->CreateSocketPerformanceWatcher(
@@ -1657,7 +1661,7 @@
void QuicStreamFactory::InitializeCachedStateInCryptoConfig(
const QuicServerId& server_id,
- const scoped_ptr<QuicServerInfo>& server_info,
+ const std::unique_ptr<QuicServerInfo>& server_info,
QuicConnectionId* connection_id) {
QuicCryptoClientConfig::CachedState* cached =
crypto_config_.LookupOrCreate(server_id);
@@ -1712,7 +1716,7 @@
return;
// Create a temporary QuicServerInfo object to deserialize and to populate the
// in-memory crypto server config cache in the MRU order.
- scoped_ptr<QuicServerInfo> server_info;
+ std::unique_ptr<QuicServerInfo> server_info;
CompletionCallback callback;
// Get the list of servers to be deserialized first because WaitForDataReady
// touches quic_server_info_map.
diff --git a/net/quic/quic_stream_factory.h b/net/quic/quic_stream_factory.h
index c2dbfbcf8..c7f10d1 100644
--- a/net/quic/quic_stream_factory.h
+++ b/net/quic/quic_stream_factory.h
@@ -91,9 +91,9 @@
// returns the amount of time waiting job should be delayed.
base::TimeDelta GetTimeDelayForWaitingJob() const;
- scoped_ptr<QuicHttpStream> CreateStream();
+ std::unique_ptr<QuicHttpStream> CreateStream();
- scoped_ptr<BidirectionalStreamImpl> CreateBidirectionalStreamImpl();
+ std::unique_ptr<BidirectionalStreamImpl> CreateBidirectionalStreamImpl();
// Sets |session_|.
void SetSession(QuicChromiumClientSession* session);
@@ -229,7 +229,7 @@
// Closes all current sessions with specified network and QUIC error codes.
void CloseAllSessions(int error, QuicErrorCode quic_error);
- scoped_ptr<base::Value> QuicStreamFactoryInfoToValue() const;
+ std::unique_ptr<base::Value> QuicStreamFactoryInfoToValue() const;
// Delete all cached state objects in |crypto_config_|.
void ClearCachedStatesInCryptoConfig();
@@ -358,7 +358,7 @@
const BoundNetLog& net_log);
// Returns a newly created QuicHttpStream owned by the caller.
- scoped_ptr<QuicHttpStream> CreateFromSession(
+ std::unique_ptr<QuicHttpStream> CreateFromSession(
QuicChromiumClientSession* session);
bool OnResolution(const QuicServerId& server_id,
@@ -368,7 +368,7 @@
bool HasActiveJob(const QuicServerId& server_id) const;
int CreateSession(const QuicServerId& server_id,
int cert_verify_flags,
- scoped_ptr<QuicServerInfo> quic_server_info,
+ std::unique_ptr<QuicServerInfo> quic_server_info,
const AddressList& address_list,
base::TimeTicks dns_resolution_end_time,
const BoundNetLog& net_log,
@@ -393,7 +393,7 @@
// if any, and otherwise leaves it unchanged.
void InitializeCachedStateInCryptoConfig(
const QuicServerId& server_id,
- const scoped_ptr<QuicServerInfo>& server_info,
+ const std::unique_ptr<QuicServerInfo>& server_info,
QuicConnectionId* connection_id);
// Initialize |quic_supported_servers_at_startup_| with the list of servers
@@ -416,10 +416,10 @@
base::WeakPtr<HttpServerProperties> http_server_properties_;
TransportSecurityState* transport_security_state_;
CTVerifier* cert_transparency_verifier_;
- scoped_ptr<QuicServerInfoFactory> quic_server_info_factory_;
+ std::unique_ptr<QuicServerInfoFactory> quic_server_info_factory_;
QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
QuicRandom* random_generator_;
- scoped_ptr<QuicClock> clock_;
+ std::unique_ptr<QuicClock> clock_;
const size_t max_packet_length_;
// Factory which is used to create socket performance watcher. A new watcher
@@ -428,7 +428,7 @@
SocketPerformanceWatcherFactory* socket_performance_watcher_factory_;
// The helper used for all connections.
- scoped_ptr<QuicChromiumConnectionHelper> helper_;
+ std::unique_ptr<QuicChromiumConnectionHelper> helper_;
// Contains owning pointers to all sessions that currently exist.
SessionIdMap all_sessions_;
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index e6fffab..794e40af21 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -187,9 +187,9 @@
}
private:
- scoped_ptr<NetworkChangeNotifier::DisableForTest>
+ std::unique_ptr<NetworkChangeNotifier::DisableForTest>
disable_network_change_notifier_for_tests_;
- scoped_ptr<MockNetworkChangeNotifier> mock_network_change_notifier_;
+ std::unique_ptr<MockNetworkChangeNotifier> mock_network_change_notifier_;
};
class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
@@ -280,7 +280,7 @@
host_port_pair);
}
- scoped_ptr<QuicHttpStream> CreateFromSession(
+ std::unique_ptr<QuicHttpStream> CreateFromSession(
const HostPortPair& host_port_pair) {
QuicChromiumClientSession* session =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair);
@@ -313,7 +313,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
stream.reset();
@@ -337,12 +337,12 @@
return socket_factory_.udp_client_socket_ports()[socket_count];
}
- scoped_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket(
QuicPacketNumber num) {
return maker_.MakeConnectionClosePacket(num);
}
- scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
+ std::unique_ptr<QuicEncryptedPacket> ConstructRstPacket() {
QuicStreamId stream_id = kClientDataStreamId1;
return maker_.MakeRstPacket(
1, true, stream_id,
@@ -366,7 +366,7 @@
base::MessageLoop::current()->RunUntilIdle();
}
- scoped_ptr<QuicEncryptedPacket> ConstructGetRequestPacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructGetRequestPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -380,7 +380,7 @@
headers, &spdy_headers_frame_len);
}
- scoped_ptr<QuicEncryptedPacket> ConstructOkResponsePacket(
+ std::unique_ptr<QuicEncryptedPacket> ConstructOkResponsePacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -401,13 +401,13 @@
scoped_refptr<TestTaskRunner> runner_;
QuicTestPacketMaker maker_;
HttpServerPropertiesImpl http_server_properties_;
- scoped_ptr<CertVerifier> cert_verifier_;
- scoped_ptr<ChannelIDService> channel_id_service_;
+ std::unique_ptr<CertVerifier> cert_verifier_;
+ std::unique_ptr<ChannelIDService> channel_id_service_;
TransportSecurityState transport_security_state_;
- scoped_ptr<CTVerifier> cert_transparency_verifier_;
- scoped_ptr<ScopedMockNetworkChangeNotifier>
+ std::unique_ptr<CTVerifier> cert_transparency_verifier_;
+ std::unique_ptr<ScopedMockNetworkChangeNotifier>
scoped_mock_network_change_notifier_;
- scoped_ptr<QuicStreamFactory> factory_;
+ std::unique_ptr<QuicStreamFactory> factory_;
HostPortPair host_port_pair_;
GURL url_;
GURL url2_;
@@ -461,7 +461,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Will reset stream 3.
@@ -501,7 +501,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -534,7 +534,7 @@
QuicSession::HANDSHAKE_CONFIRMED);
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -567,7 +567,7 @@
QuicSession::HANDSHAKE_CONFIRMED);
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -589,7 +589,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
QuicChromiumClientSession* session =
@@ -620,7 +620,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
QuicChromiumClientSession* session =
@@ -663,7 +663,7 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -671,7 +671,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_EQ(
@@ -705,7 +705,7 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -713,7 +713,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_NE(
@@ -748,7 +748,7 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -756,7 +756,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
factory_->OnSessionGoingAway(
@@ -771,7 +771,7 @@
EXPECT_EQ(OK, request3.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback3.callback()));
- scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream3 = request3.CreateStream();
EXPECT_TRUE(stream3.get());
EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2));
@@ -803,7 +803,7 @@
EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -811,7 +811,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback_.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
@@ -846,7 +846,7 @@
EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -854,7 +854,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback_.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
@@ -899,7 +899,7 @@
EXPECT_EQ(OK, request1.Request(alternative, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET",
net_log_, callback_.callback()));
- scoped_ptr<QuicHttpStream> stream1 = request1.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream1 = request1.CreateStream();
EXPECT_TRUE(stream1.get());
QuicStreamRequest request2(factory_.get());
@@ -912,7 +912,7 @@
// SocketDataProvider is set up, the second request succeeding means that
// it pooled to the session opened by the first one.
EXPECT_EQ(OK, rv);
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
} else {
EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv);
@@ -963,7 +963,7 @@
EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -971,7 +971,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback_.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
@@ -1012,7 +1012,7 @@
EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -1020,7 +1020,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback_.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
@@ -1066,7 +1066,7 @@
EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
@@ -1074,7 +1074,7 @@
EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
/*cert_verify_flags=*/0, url2_, "GET",
net_log_, callback_.callback()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
@@ -1105,7 +1105,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Mark the session as going away. Ensure that while it is still alive
@@ -1127,7 +1127,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_TRUE(
@@ -1152,12 +1152,12 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
QuicStreamId stream_id = kClientDataStreamId1;
- scoped_ptr<QuicEncryptedPacket> client_rst(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(
maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(ASYNC, client_rst->data(), client_rst->length(), 0),
};
- scoped_ptr<QuicEncryptedPacket> server_rst(
+ std::unique_ptr<QuicEncryptedPacket> server_rst(
maker_.MakeRstPacket(1, false, stream_id, QUIC_STREAM_CANCELLED));
MockRead reads[] = {
MockRead(ASYNC, server_rst->data(), server_rst->length(), 1),
@@ -1181,7 +1181,7 @@
} else {
EXPECT_EQ(OK, rv);
}
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream);
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -1192,7 +1192,7 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
/*cert_verify_flags=*/0, url_, "GET", net_log_,
CompletionCallback()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream);
EXPECT_EQ(ERR_IO_PENDING,
stream->InitializeStream(&request_info, DEFAULT_PRIORITY, net_log_,
@@ -1271,7 +1271,7 @@
base::RunLoop().RunUntilIdle();
- scoped_ptr<QuicHttpStream> stream(CreateFromSession(host_port_pair_));
+ std::unique_ptr<QuicHttpStream> stream(CreateFromSession(host_port_pair_));
EXPECT_TRUE(stream.get());
stream.reset();
@@ -1321,7 +1321,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
+ std::unique_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
SequencedSocketData socket_data(reads, arraysize(reads),
@@ -1340,7 +1340,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -1377,7 +1377,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
+ std::unique_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
SequencedSocketData socket_data(reads, arraysize(reads),
@@ -1396,7 +1396,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -1434,7 +1434,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> request_packet(
+ std::unique_ptr<QuicEncryptedPacket> request_packet(
ConstructGetRequestPacket(1, kClientDataStreamId1, true, true));
MockWrite writes[] = {MockWrite(SYNCHRONOUS, request_packet->data(),
request_packet->length(), 1)};
@@ -1449,7 +1449,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -1473,11 +1473,11 @@
// Set up second socket data provider that is used after migration.
// The response to the earlier request is read on this new socket.
- scoped_ptr<QuicEncryptedPacket> ping(
+ std::unique_ptr<QuicEncryptedPacket> ping(
maker_.MakePingPacket(2, /*include_version=*/true));
MockWrite writes1[] = {
MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 0)};
- scoped_ptr<QuicEncryptedPacket> response_headers_packet(
+ std::unique_ptr<QuicEncryptedPacket> response_headers_packet(
ConstructOkResponsePacket(1, kClientDataStreamId1, false, false));
MockRead reads1[] = {MockRead(ASYNC, response_headers_packet->data(),
response_headers_packet->length(), 1),
@@ -1514,7 +1514,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_TRUE(
@@ -1549,7 +1549,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> request_packet(
+ std::unique_ptr<QuicEncryptedPacket> request_packet(
ConstructGetRequestPacket(1, kClientDataStreamId1, true, true));
MockWrite writes[] = {MockWrite(SYNCHRONOUS, request_packet->data(),
request_packet->length(), 1)};
@@ -1564,7 +1564,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -1587,13 +1587,13 @@
callback_.callback()));
// Set up second socket data provider that is used after migration.
- scoped_ptr<QuicEncryptedPacket> ping(
+ std::unique_ptr<QuicEncryptedPacket> ping(
maker_.MakePingPacket(2, /*include_version=*/true));
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
3, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes1[] = {
MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 0)};
- scoped_ptr<QuicEncryptedPacket> response_packet(
+ std::unique_ptr<QuicEncryptedPacket> response_packet(
ConstructOkResponsePacket(1, kClientDataStreamId1, false, false));
MockRead reads1[] = {
MockRead(ASYNC, response_packet->data(), response_packet->length(), 1),
@@ -1625,7 +1625,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_TRUE(
@@ -1650,7 +1650,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -1666,7 +1666,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -1704,7 +1704,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
MockWrite writes[] = {
MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1),
@@ -1720,7 +1720,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -1753,7 +1753,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -1769,7 +1769,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -1805,7 +1805,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
MockWrite writes[] = {
MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1),
@@ -1821,7 +1821,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -1856,7 +1856,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -1872,7 +1872,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created, but marked as non-migratable.
@@ -1910,7 +1910,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -1926,7 +1926,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -1966,7 +1966,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
MockWrite writes[] = {
MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1),
@@ -1982,7 +1982,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created, but marked as non-migratable.
@@ -2018,7 +2018,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
MockWrite writes[] = {
MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1),
@@ -2034,7 +2034,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -2082,7 +2082,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Ensure that session is alive and active.
@@ -2120,7 +2120,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Ensure that session is alive and active.
@@ -2149,7 +2149,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> request_packet(
+ std::unique_ptr<QuicEncryptedPacket> request_packet(
ConstructGetRequestPacket(1, kClientDataStreamId1, true, true));
MockWrite writes[] = {MockWrite(SYNCHRONOUS, request_packet->data(),
request_packet->length(), 1)};
@@ -2164,7 +2164,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -2188,11 +2188,11 @@
// Set up second socket data provider that is used after migration.
// The response to the earlier request is read on this new socket.
- scoped_ptr<QuicEncryptedPacket> ping(
+ std::unique_ptr<QuicEncryptedPacket> ping(
maker_.MakePingPacket(2, /*include_version=*/true));
MockWrite writes1[] = {
MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 0)};
- scoped_ptr<QuicEncryptedPacket> response_headers_packet(
+ std::unique_ptr<QuicEncryptedPacket> response_headers_packet(
ConstructOkResponsePacket(1, kClientDataStreamId1, false, false));
MockRead reads1[] = {MockRead(ASYNC, response_headers_packet->data(),
response_headers_packet->length(), 1),
@@ -2232,7 +2232,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_TRUE(
@@ -2271,7 +2271,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -2287,7 +2287,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -2327,7 +2327,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -2343,7 +2343,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created, but marked as non-migratable.
@@ -2383,7 +2383,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -2399,7 +2399,7 @@
/*cert_verify_flags=*/0, url_, "GET", net_log_,
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
// Cause QUIC stream to be created.
@@ -2442,7 +2442,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
+ std::unique_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
SequencedSocketData socket_data(reads, arraysize(reads),
@@ -2461,7 +2461,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -2497,7 +2497,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
+ std::unique_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
SequencedSocketData socket_data(reads, arraysize(reads),
@@ -2516,7 +2516,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -2553,7 +2553,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
+ std::unique_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
SequencedSocketData socket_data(reads, arraysize(reads),
@@ -2572,7 +2572,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -2720,7 +2720,7 @@
runner_->RunNextTask();
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -2755,7 +2755,7 @@
// the CancelWaitForDataReady task hasn't been posted.
ASSERT_EQ(0u, runner_->GetPostedTasks().size());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -2916,13 +2916,13 @@
QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server4));
EXPECT_FALSE(HasActiveSession(server4));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
- scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream3 = request3.CreateStream();
EXPECT_TRUE(stream3.get());
- scoped_ptr<QuicHttpStream> stream4 = request4.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream4 = request4.CreateStream();
EXPECT_TRUE(stream4.get());
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -3009,9 +3009,9 @@
QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
factory_->QuicDisabledReason(host_port_pair_.port()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_FALSE(stream.get()); // Session is already closed.
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_FALSE(stream2.get()); // Session is already closed.
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -3057,7 +3057,7 @@
QuicChromiumClientSession* session =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
@@ -3087,7 +3087,7 @@
QuicChromiumClientSession* session2 =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -3219,11 +3219,11 @@
QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
factory_->QuicDisabledReason(host_port_pair_.port()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_FALSE(stream.get()); // Session is already closed.
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_FALSE(stream2.get()); // Session is already closed.
- scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream3 = request3.CreateStream();
EXPECT_FALSE(stream3.get()); // Session is already closed.
EXPECT_TRUE(socket_data.AllReadDataConsumed());
@@ -3280,7 +3280,7 @@
QuicChromiumClientSession* session =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
@@ -3332,7 +3332,7 @@
QuicChromiumClientSession* session3 =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3);
- scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream3 = request3.CreateStream();
EXPECT_TRUE(stream3.get());
EXPECT_EQ(OK, stream3->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -3349,7 +3349,7 @@
EXPECT_EQ(QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS,
factory_->QuicDisabledReason(host_port_pair_.port()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_FALSE(stream2.get()); // Session is already closed.
// Verify that QUIC is un-disabled after a network change.
@@ -3399,7 +3399,7 @@
QuicChromiumClientSession* session =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
@@ -3561,13 +3561,13 @@
EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
host_port_pair_.port()));
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_FALSE(stream.get()); // Session is already closed.
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_FALSE(stream2.get()); // Session is already closed.
- scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream3 = request3.CreateStream();
EXPECT_FALSE(stream3.get()); // Session is already closed.
- scoped_ptr<QuicHttpStream> stream4 = request4.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream4 = request4.CreateStream();
EXPECT_FALSE(stream4.get()); // Session is already closed.
EXPECT_TRUE(socket_data.AllReadDataConsumed());
@@ -3632,7 +3632,7 @@
QuicChromiumClientSession* session =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
HttpRequestInfo request_info;
EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
@@ -3702,7 +3702,7 @@
QuicChromiumClientSession* session4 =
QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server4);
- scoped_ptr<QuicHttpStream> stream4 = request4.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream4 = request4.CreateStream();
EXPECT_TRUE(stream4.get());
EXPECT_EQ(OK, stream4->InitializeStream(&request_info, DEFAULT_PRIORITY,
net_log_, CompletionCallback()));
@@ -3717,9 +3717,9 @@
EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
host_port_pair_.port()));
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_FALSE(stream2.get()); // Session is already closed.
- scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream3 = request3.CreateStream();
EXPECT_FALSE(stream3.get()); // Session is already closed.
EXPECT_TRUE(socket_data.AllReadDataConsumed());
@@ -3775,7 +3775,7 @@
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -3821,7 +3821,7 @@
http_server_properties_.GetWeakPtr());
factory_->set_quic_server_info_factory(quic_server_info_factory);
- scoped_ptr<QuicServerInfo> quic_server_info(
+ std::unique_ptr<QuicServerInfo> quic_server_info(
quic_server_info_factory->GetForServer(quic_server_id));
// Update quic_server_info's server_config and persist it.
@@ -3859,7 +3859,7 @@
quic_server_info->Persist();
QuicServerId quic_server_id2(kServer2HostName, 80, PRIVACY_MODE_DISABLED);
- scoped_ptr<QuicServerInfo> quic_server_info2(
+ std::unique_ptr<QuicServerInfo> quic_server_info2(
quic_server_info_factory->GetForServer(quic_server_id2));
// Update quic_server_info2's server_config and persist it.
@@ -3966,7 +3966,7 @@
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
QuicStreamFactoryPeer::SetYieldAfterPackets(factory_.get(), 0);
- scoped_ptr<QuicEncryptedPacket> close_packet(
+ std::unique_ptr<QuicEncryptedPacket> close_packet(
ConstructConnectionClosePacket(0));
vector<MockRead> reads;
reads.push_back(
@@ -4002,7 +4002,7 @@
// yielded the read.
EXPECT_EQ(1u, observer.executed_count());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_FALSE(stream.get()); // Session is already closed.
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -4015,7 +4015,7 @@
QuicStreamFactoryPeer::SetYieldAfterDuration(
factory_.get(), QuicTime::Delta::FromMilliseconds(-1));
- scoped_ptr<QuicEncryptedPacket> close_packet(
+ std::unique_ptr<QuicEncryptedPacket> close_packet(
ConstructConnectionClosePacket(0));
vector<MockRead> reads;
reads.push_back(
@@ -4051,7 +4051,7 @@
// yielded the read.
EXPECT_EQ(1u, observer.executed_count());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_FALSE(stream.get()); // Session is already closed.
EXPECT_TRUE(socket_data.AllReadDataConsumed());
EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -4073,7 +4073,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
@@ -4103,7 +4103,7 @@
MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
- scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+ std::unique_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
1, true, kServerDataStreamId1, QUIC_STREAM_CANCELLED));
MockWrite writes[] = {
MockWrite(SYNCHRONOUS, client_rst->data(), client_rst->length(), 1),
@@ -4123,7 +4123,7 @@
callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream = request.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
EXPECT_TRUE(stream.get());
EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
@@ -4152,7 +4152,7 @@
EXPECT_EQ(index->GetPromised(url), nullptr);
EXPECT_EQ(OK, callback_.WaitForResult());
- scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
+ std::unique_ptr<QuicHttpStream> stream2 = request2.CreateStream();
EXPECT_TRUE(stream2.get());
EXPECT_TRUE(socket_data1.AllReadDataConsumed());
diff --git a/net/quic/quic_stream_sequencer_test.cc b/net/quic/quic_stream_sequencer_test.cc
index b66bf1d..ed55119 100644
--- a/net/quic/quic_stream_sequencer_test.cc
+++ b/net/quic/quic_stream_sequencer_test.cc
@@ -150,7 +150,7 @@
MockClock clock_;
MockQuicSpdySession session_;
testing::StrictMock<MockStream> stream_;
- scoped_ptr<QuicStreamSequencer> sequencer_;
+ std::unique_ptr<QuicStreamSequencer> sequencer_;
};
// TODO(rch): reorder these tests so they build on each other.
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index 58a99d38..a4bd67d8 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -149,7 +149,7 @@
protected:
MockConnectionHelper helper_;
MockConnection* connection_;
- scoped_ptr<MockQuicSpdySession> session_;
+ std::unique_ptr<MockQuicSpdySession> session_;
TestStream* stream_;
SpdyHeaderBlock headers_;
QuicWriteBlockedList* write_blocked_list_;
diff --git a/net/quic/spdy_utils.cc b/net/quic/spdy_utils.cc
index 68dadb57..7343ccea 100644
--- a/net/quic/spdy_utils.cc
+++ b/net/quic/spdy_utils.cc
@@ -4,9 +4,9 @@
#include "net/quic/spdy_utils.h"
+#include <memory>
#include <vector>
-#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
diff --git a/net/quic/test_tools/crypto_test_utils.cc b/net/quic/test_tools/crypto_test_utils.cc
index 67092d8..fc13ff35 100644
--- a/net/quic/test_tools/crypto_test_utils.cc
+++ b/net/quic/test_tools/crypto_test_utils.cc
@@ -84,7 +84,7 @@
// ChannelIDSource implementation.
QuicAsyncStatus GetChannelIDKey(const string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* callback) override {
// Synchronous mode.
if (!callback) {
@@ -110,9 +110,9 @@
}
private:
- scoped_ptr<ChannelIDSource> sync_source_;
- scoped_ptr<ChannelIDSourceCallback> callback_;
- scoped_ptr<ChannelIDKey> channel_id_key_;
+ std::unique_ptr<ChannelIDSource> sync_source_;
+ std::unique_ptr<ChannelIDSourceCallback> callback_;
+ std::unique_ptr<ChannelIDKey> channel_id_key_;
};
} // anonymous namespace
@@ -197,7 +197,7 @@
CompareClientAndServerKeys(client_session.GetCryptoStream(), server);
if (options.channel_id_enabled) {
- scoped_ptr<ChannelIDKey> channel_id_key;
+ std::unique_ptr<ChannelIDKey> channel_id_key;
QuicAsyncStatus status = crypto_config.channel_id_source()->GetChannelIDKey(
server_id.host(), &channel_id_key, nullptr);
EXPECT_EQ(QUIC_SUCCESS, status);
@@ -221,7 +221,7 @@
QuicCryptoServerConfig::ConfigOptions options;
options.channel_id_enabled = true;
options.token_binding_enabled = fake_options.token_binding_enabled;
- scoped_ptr<CryptoHandshakeMessage> scfg(
+ std::unique_ptr<CryptoHandshakeMessage> scfg(
crypto_config->AddDefaultConfig(rand, clock, options));
}
@@ -575,7 +575,7 @@
len--;
CHECK_EQ(0u, len % 2);
- scoped_ptr<uint8_t[]> buf(new uint8_t[len / 2]);
+ std::unique_ptr<uint8_t[]> buf(new uint8_t[len / 2]);
for (size_t i = 0; i < len / 2; i++) {
uint8_t v = 0;
@@ -595,8 +595,8 @@
// The CryptoHandshakeMessage needs to be serialized and parsed to ensure
// that any padding is included.
- scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
- scoped_ptr<CryptoHandshakeMessage> parsed(
+ std::unique_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
+ std::unique_ptr<CryptoHandshakeMessage> parsed(
CryptoFramer::ParseMessage(bytes->AsStringPiece()));
CHECK(parsed.get());
diff --git a/net/quic/test_tools/crypto_test_utils_chromium.cc b/net/quic/test_tools/crypto_test_utils_chromium.cc
index 3932f31..d78df969 100644
--- a/net/quic/test_tools/crypto_test_utils_chromium.cc
+++ b/net/quic/test_tools/crypto_test_utils_chromium.cc
@@ -2,15 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "net/quic/test_tools/crypto_test_utils.h"
-
+#include <memory>
#include <utility>
#include "base/callback_helpers.h"
#include "base/logging.h"
#include "base/macros.h"
+#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "base/strings/stringprintf.h"
#include "net/base/net_errors.h"
@@ -30,6 +29,7 @@
#include "net/quic/crypto/crypto_utils.h"
#include "net/quic/crypto/proof_source_chromium.h"
#include "net/quic/crypto/proof_verifier_chromium.h"
+#include "net/quic/test_tools/crypto_test_utils.h"
#include "net/ssl/ssl_config_service.h"
#include "net/test/cert_test_util.h"
@@ -47,9 +47,9 @@
class TestProofVerifierChromium : public ProofVerifierChromium {
public:
TestProofVerifierChromium(
- scoped_ptr<CertVerifier> cert_verifier,
- scoped_ptr<TransportSecurityState> transport_security_state,
- scoped_ptr<CTVerifier> cert_transparency_verifier,
+ std::unique_ptr<CertVerifier> cert_verifier,
+ std::unique_ptr<TransportSecurityState> transport_security_state,
+ std::unique_ptr<CTVerifier> cert_transparency_verifier,
const std::string& cert_file)
: ProofVerifierChromium(cert_verifier.get(),
nullptr,
@@ -70,9 +70,9 @@
private:
ScopedTestRoot scoped_root_;
- scoped_ptr<CertVerifier> cert_verifier_;
- scoped_ptr<TransportSecurityState> transport_security_state_;
- scoped_ptr<CTVerifier> cert_transparency_verifier_;
+ std::unique_ptr<CertVerifier> cert_verifier_;
+ std::unique_ptr<TransportSecurityState> transport_security_state_;
+ std::unique_ptr<CTVerifier> cert_transparency_verifier_;
};
const char kSignature[] = "signature";
@@ -138,10 +138,11 @@
class FakeProofVerifier : public TestProofVerifierChromium {
public:
- FakeProofVerifier(scoped_ptr<CertVerifier> cert_verifier,
- scoped_ptr<TransportSecurityState> transport_security_state,
- scoped_ptr<CTVerifier> cert_transparency_verifier,
- const std::string& cert_file)
+ FakeProofVerifier(
+ std::unique_ptr<CertVerifier> cert_verifier,
+ std::unique_ptr<TransportSecurityState> transport_security_state,
+ std::unique_ptr<CTVerifier> cert_transparency_verifier,
+ const std::string& cert_file)
: TestProofVerifierChromium(std::move(cert_verifier),
std::move(transport_security_state),
std::move(cert_transparency_verifier),
@@ -149,20 +150,21 @@
~FakeProofVerifier() override {}
// ProofVerifier interface
- QuicAsyncStatus VerifyProof(const std::string& hostname,
- const uint16_t port,
- const std::string& server_config,
- QuicVersion quic_version,
- StringPiece chlo_hash,
- const std::vector<std::string>& certs,
- const std::string& cert_sct,
- const std::string& signature,
- const ProofVerifyContext* verify_context,
- std::string* error_details,
- scoped_ptr<ProofVerifyDetails>* verify_details,
- ProofVerifierCallback* callback) override {
+ QuicAsyncStatus VerifyProof(
+ const std::string& hostname,
+ const uint16_t port,
+ const std::string& server_config,
+ QuicVersion quic_version,
+ StringPiece chlo_hash,
+ const std::vector<std::string>& certs,
+ const std::string& cert_sct,
+ const std::string& signature,
+ const ProofVerifyContext* verify_context,
+ std::string* error_details,
+ std::unique_ptr<ProofVerifyDetails>* verify_details,
+ ProofVerifierCallback* callback) override {
error_details->clear();
- scoped_ptr<ProofVerifyDetailsChromium> verify_details_chromium(
+ std::unique_ptr<ProofVerifyDetailsChromium> verify_details_chromium(
new ProofVerifyDetailsChromium);
DCHECK(!certs.empty());
// Convert certs to X509Certificate.
@@ -183,7 +185,7 @@
const ProofVerifyContextChromium* chromium_context =
reinterpret_cast<const ProofVerifyContextChromium*>(verify_context);
- scoped_ptr<CertVerifier::Request> cert_verifier_request_;
+ std::unique_ptr<CertVerifier::Request> cert_verifier_request_;
TestCompletionCallback test_callback;
int result = cert_verifier()->Verify(
x509_cert.get(), hostname, std::string(),
@@ -235,7 +237,7 @@
// static
ProofVerifier* ProofVerifierForTestingInternal(bool use_real_proof_verifier) {
// TODO(rch): use a real cert verifier?
- scoped_ptr<MockCertVerifier> cert_verifier(new MockCertVerifier());
+ std::unique_ptr<MockCertVerifier> cert_verifier(new MockCertVerifier());
net::CertVerifyResult verify_result;
verify_result.verified_cert =
ImportCertFromFile(GetTestCertsDirectory(), "quic_test.example.com.crt");
@@ -247,17 +249,17 @@
"test.example.com", verify_result, OK);
if (use_real_proof_verifier) {
return new TestProofVerifierChromium(
- std::move(cert_verifier), make_scoped_ptr(new TransportSecurityState),
- make_scoped_ptr(new MultiLogCTVerifier), "quic_root.crt");
+ std::move(cert_verifier), base::WrapUnique(new TransportSecurityState),
+ base::WrapUnique(new MultiLogCTVerifier), "quic_root.crt");
}
#if defined(USE_OPENSSL)
return new TestProofVerifierChromium(
- std::move(cert_verifier), make_scoped_ptr(new TransportSecurityState),
- make_scoped_ptr(new MultiLogCTVerifier), "quic_root.crt");
+ std::move(cert_verifier), base::WrapUnique(new TransportSecurityState),
+ base::WrapUnique(new MultiLogCTVerifier), "quic_root.crt");
#else
return new FakeProofVerifier(
- std::move(cert_verifier), make_scoped_ptr(new TransportSecurityState),
- make_scoped_ptr(new MultiLogCTVerifier), "quic_root.crt");
+ std::move(cert_verifier), base::WrapUnique(new TransportSecurityState),
+ base::WrapUnique(new MultiLogCTVerifier), "quic_root.crt");
#endif
}
diff --git a/net/quic/test_tools/crypto_test_utils_nss.cc b/net/quic/test_tools/crypto_test_utils_nss.cc
index 946b0531..c34dc01 100644
--- a/net/quic/test_tools/crypto_test_utils_nss.cc
+++ b/net/quic/test_tools/crypto_test_utils_nss.cc
@@ -2,14 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "net/quic/test_tools/crypto_test_utils.h"
-
+#include "base/memory/ptr_util.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
#include "crypto/ec_private_key.h"
#include "crypto/ec_signature_creator.h"
#include "net/quic/crypto/channel_id.h"
#include "net/quic/crypto/channel_id_chromium.h"
+#include "net/quic/test_tools/crypto_test_utils.h"
using base::StringPiece;
using std::string;
@@ -26,7 +26,7 @@
QuicAsyncStatus GetChannelIDKey(
const string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* /*callback*/) override {
channel_id_key->reset(new ChannelIDKeyChromium(HostnameToKey(hostname)));
return QUIC_SUCCESS;
@@ -35,10 +35,10 @@
private:
typedef std::map<string, crypto::ECPrivateKey*> HostnameToKeyMap;
- scoped_ptr<crypto::ECPrivateKey> HostnameToKey(const string& hostname) {
+ std::unique_ptr<crypto::ECPrivateKey> HostnameToKey(const string& hostname) {
HostnameToKeyMap::const_iterator it = hostname_to_key_.find(hostname);
if (it != hostname_to_key_.end()) {
- return make_scoped_ptr(it->second->Copy());
+ return base::WrapUnique(it->second->Copy());
}
crypto::ECPrivateKey* keypair = crypto::ECPrivateKey::Create();
@@ -46,7 +46,7 @@
return nullptr;
}
hostname_to_key_[hostname] = keypair;
- return make_scoped_ptr(keypair->Copy());
+ return base::WrapUnique(keypair->Copy());
}
HostnameToKeyMap hostname_to_key_;
diff --git a/net/quic/test_tools/crypto_test_utils_openssl.cc b/net/quic/test_tools/crypto_test_utils_openssl.cc
index 80228ee..2c39122 100644
--- a/net/quic/test_tools/crypto_test_utils_openssl.cc
+++ b/net/quic/test_tools/crypto_test_utils_openssl.cc
@@ -49,7 +49,7 @@
return false;
}
- scoped_ptr<uint8_t[]> der_sig(new uint8_t[sig_len]);
+ std::unique_ptr<uint8_t[]> der_sig(new uint8_t[sig_len]);
if (!EVP_DigestSignFinal(md_ctx.get(), der_sig.get(), &sig_len)) {
return false;
}
@@ -63,7 +63,7 @@
// The signature consists of a pair of 32-byte numbers.
static const size_t kSignatureLength = 32 * 2;
- scoped_ptr<uint8_t[]> signature(new uint8_t[kSignatureLength]);
+ std::unique_ptr<uint8_t[]> signature(new uint8_t[kSignatureLength]);
if (!BN_bn2bin_padded(&signature[0], 32, sig->r) ||
!BN_bn2bin_padded(&signature[32], 32, sig->s)) {
return false;
@@ -105,7 +105,7 @@
QuicAsyncStatus GetChannelIDKey(
const string& hostname,
- scoped_ptr<ChannelIDKey>* channel_id_key,
+ std::unique_ptr<ChannelIDKey>* channel_id_key,
ChannelIDSourceCallback* /*callback*/) override {
channel_id_key->reset(new TestChannelIDKey(HostnameToKey(hostname)));
return QUIC_SUCCESS;
diff --git a/net/quic/test_tools/mock_crypto_client_stream_factory.cc b/net/quic/test_tools/mock_crypto_client_stream_factory.cc
index 52501788b..eb35bfd0 100644
--- a/net/quic/test_tools/mock_crypto_client_stream_factory.cc
+++ b/net/quic/test_tools/mock_crypto_client_stream_factory.cc
@@ -23,7 +23,7 @@
MockCryptoClientStreamFactory::CreateQuicCryptoClientStream(
const QuicServerId& server_id,
QuicChromiumClientSession* session,
- scoped_ptr<ProofVerifyContext> /*proof_verify_context*/,
+ std::unique_ptr<ProofVerifyContext> /*proof_verify_context*/,
QuicCryptoClientConfig* crypto_config) {
const ProofVerifyDetailsChromium* proof_verify_details = nullptr;
if (!proof_verify_details_queue_.empty()) {
diff --git a/net/quic/test_tools/mock_crypto_client_stream_factory.h b/net/quic/test_tools/mock_crypto_client_stream_factory.h
index 1a12a39..db64c3a 100644
--- a/net/quic/test_tools/mock_crypto_client_stream_factory.h
+++ b/net/quic/test_tools/mock_crypto_client_stream_factory.h
@@ -26,7 +26,7 @@
QuicCryptoClientStream* CreateQuicCryptoClientStream(
const QuicServerId& server_id,
QuicChromiumClientSession* session,
- scoped_ptr<ProofVerifyContext> proof_verify_context,
+ std::unique_ptr<ProofVerifyContext> proof_verify_context,
QuicCryptoClientConfig* crypto_config) override;
void set_handshake_mode(
diff --git a/net/quic/test_tools/quic_stream_factory_peer.cc b/net/quic/test_tools/quic_stream_factory_peer.cc
index bcb7ba7..0d58f20a 100644
--- a/net/quic/test_tools/quic_stream_factory_peer.cc
+++ b/net/quic/test_tools/quic_stream_factory_peer.cc
@@ -40,7 +40,7 @@
return factory->active_sessions_[server_id];
}
-scoped_ptr<QuicHttpStream> QuicStreamFactoryPeer::CreateFromSession(
+std::unique_ptr<QuicHttpStream> QuicStreamFactoryPeer::CreateFromSession(
QuicStreamFactory* factory,
QuicChromiumClientSession* session) {
return factory->CreateFromSession(session);
diff --git a/net/quic/test_tools/quic_stream_factory_peer.h b/net/quic/test_tools/quic_stream_factory_peer.h
index c2d2993..e0d85a3 100644
--- a/net/quic/test_tools/quic_stream_factory_peer.h
+++ b/net/quic/test_tools/quic_stream_factory_peer.h
@@ -40,7 +40,7 @@
QuicStreamFactory* factory,
const HostPortPair& host_port_pair);
- static scoped_ptr<QuicHttpStream> CreateFromSession(
+ static std::unique_ptr<QuicHttpStream> CreateFromSession(
QuicStreamFactory* factory,
QuicChromiumClientSession* session);
diff --git a/net/quic/test_tools/quic_test_packet_maker.cc b/net/quic/test_tools/quic_test_packet_maker.cc
index 67e0ffa..99f5712 100644
--- a/net/quic/test_tools/quic_test_packet_maker.cc
+++ b/net/quic/test_tools/quic_test_packet_maker.cc
@@ -33,7 +33,7 @@
host_.assign(host);
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePingPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePingPacket(
QuicPacketNumber num,
bool include_version) {
QuicPacketHeader header;
@@ -47,10 +47,11 @@
header.fec_group = 0;
QuicPingFrame ping;
- return scoped_ptr<QuicReceivedPacket>(MakePacket(header, QuicFrame(ping)));
+ return std::unique_ptr<QuicReceivedPacket>(
+ MakePacket(header, QuicFrame(ping)));
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
QuicPacketNumber num,
bool include_version,
QuicStreamId stream_id,
@@ -58,7 +59,7 @@
return MakeRstPacket(num, include_version, stream_id, error_code, 0);
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
QuicPacketNumber num,
bool include_version,
QuicStreamId stream_id,
@@ -76,10 +77,11 @@
QuicRstStreamFrame rst(stream_id, error_code, bytes_written);
DVLOG(1) << "Adding frame: " << QuicFrame(&rst);
- return scoped_ptr<QuicReceivedPacket>(MakePacket(header, QuicFrame(&rst)));
+ return std::unique_ptr<QuicReceivedPacket>(
+ MakePacket(header, QuicFrame(&rst)));
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
QuicPacketNumber num,
bool include_version,
QuicStreamId stream_id,
@@ -118,7 +120,7 @@
QuicFramer framer(SupportedVersions(version_), clock_->Now(),
Perspective::IS_CLIENT);
- scoped_ptr<QuicPacket> packet(
+ std::unique_ptr<QuicPacket> packet(
BuildUnsizedDataPacket(&framer, header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
@@ -126,10 +128,10 @@
buffer, kMaxPacketSize);
EXPECT_NE(0u, encrypted_size);
QuicReceivedPacket encrypted(buffer, encrypted_size, QuicTime::Zero(), false);
- return scoped_ptr<QuicReceivedPacket>(encrypted.Clone());
+ return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
}
-scoped_ptr<QuicReceivedPacket>
+std::unique_ptr<QuicReceivedPacket>
QuicTestPacketMaker::MakeAckAndConnectionClosePacket(
QuicPacketNumber num,
bool include_version,
@@ -171,7 +173,7 @@
QuicFramer framer(SupportedVersions(version_), clock_->Now(),
Perspective::IS_CLIENT);
- scoped_ptr<QuicPacket> packet(
+ std::unique_ptr<QuicPacket> packet(
BuildUnsizedDataPacket(&framer, header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
@@ -179,11 +181,11 @@
buffer, kMaxPacketSize);
EXPECT_NE(0u, encrypted_size);
QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
- return scoped_ptr<QuicReceivedPacket>(encrypted.Clone());
+ return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeConnectionClosePacket(
- QuicPacketNumber num) {
+std::unique_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeConnectionClosePacket(QuicPacketNumber num) {
QuicPacketHeader header;
header.public_header.connection_id = connection_id_;
header.public_header.reset_flag = false;
@@ -197,10 +199,11 @@
QuicConnectionCloseFrame close;
close.error_code = QUIC_CRYPTO_VERSION_NOT_SUPPORTED;
close.error_details = "Time to panic!";
- return scoped_ptr<QuicReceivedPacket>(MakePacket(header, QuicFrame(&close)));
+ return std::unique_ptr<QuicReceivedPacket>(
+ MakePacket(header, QuicFrame(&close)));
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeGoAwayPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeGoAwayPacket(
QuicPacketNumber num,
QuicErrorCode error_code,
std::string reason_phrase) {
@@ -218,12 +221,13 @@
goaway.error_code = error_code;
goaway.last_good_stream_id = 0;
goaway.reason_phrase = reason_phrase;
- return scoped_ptr<QuicReceivedPacket>(MakePacket(header, QuicFrame(&goaway)));
+ return std::unique_ptr<QuicReceivedPacket>(
+ MakePacket(header, QuicFrame(&goaway)));
}
// Sets both least_unacked fields in stop waiting frame and ack frame
// to be |least_unacked|.
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber least_unacked,
@@ -232,7 +236,7 @@
least_unacked, send_feedback);
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber ack_least_unacked,
@@ -263,7 +267,7 @@
stop_waiting.least_unacked = stop_least_unacked;
frames.push_back(QuicFrame(&stop_waiting));
- scoped_ptr<QuicPacket> packet(
+ std::unique_ptr<QuicPacket> packet(
BuildUnsizedDataPacket(&framer, header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
@@ -271,11 +275,11 @@
buffer, kMaxPacketSize);
EXPECT_NE(0u, encrypted_size);
QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
- return scoped_ptr<QuicReceivedPacket>(encrypted.Clone());
+ return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
}
// Returns a newly created packet to send kData on stream 1.
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeDataPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeDataPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -287,7 +291,7 @@
return MakePacket(header_, QuicFrame(&frame));
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndDataPacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndDataPacket(
QuicPacketNumber packet_number,
bool include_version,
QuicStreamId stream_id,
@@ -316,7 +320,8 @@
return MakeMultipleFramesPacket(header_, frames);
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
+std::unique_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -331,15 +336,15 @@
// If |offset| is provided, will use the value when creating the packet.
// Will also update the value after packet creation.
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
- QuicPacketNumber packet_number,
- QuicStreamId stream_id,
- bool should_include_version,
- bool fin,
- SpdyPriority priority,
- const SpdyHeaderBlock& headers,
- size_t* spdy_headers_frame_length,
- QuicStreamOffset* offset) {
+std::unique_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeRequestHeadersPacket(QuicPacketNumber packet_number,
+ QuicStreamId stream_id,
+ bool should_include_version,
+ bool fin,
+ SpdyPriority priority,
+ const SpdyHeaderBlock& headers,
+ size_t* spdy_headers_frame_length,
+ QuicStreamOffset* offset) {
InitializeHeader(packet_number, should_include_version);
SpdySerializedFrame spdy_frame;
if (spdy_request_framer_.protocol_version() == SPDY3) {
@@ -376,7 +381,7 @@
// Convenience method for calling MakeRequestHeadersPacket with nullptr for
// |spdy_headers_frame_length|.
-scoped_ptr<QuicReceivedPacket>
+std::unique_ptr<QuicReceivedPacket>
QuicTestPacketMaker::MakeRequestHeadersPacketWithOffsetTracking(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
@@ -392,7 +397,8 @@
// If |offset| is provided, will use the value when creating the packet.
// Will also update the value after packet creation.
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
+std::unique_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -430,7 +436,8 @@
}
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
+std::unique_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -444,7 +451,7 @@
// Convenience method for calling MakeResponseHeadersPacket with nullptr for
// |spdy_headers_frame_length|.
-scoped_ptr<QuicReceivedPacket>
+std::unique_ptr<QuicReceivedPacket>
QuicTestPacketMaker::MakeResponseHeadersPacketWithOffsetTracking(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
@@ -487,7 +494,7 @@
return headers;
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePacket(
+std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePacket(
const QuicPacketHeader& header,
const QuicFrame& frame) {
QuicFrames frames;
@@ -495,12 +502,12 @@
return MakeMultipleFramesPacket(header, frames);
}
-scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeMultipleFramesPacket(
- const QuicPacketHeader& header,
- const QuicFrames& frames) {
+std::unique_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeMultipleFramesPacket(const QuicPacketHeader& header,
+ const QuicFrames& frames) {
QuicFramer framer(SupportedVersions(version_), clock_->Now(),
Perspective::IS_CLIENT);
- scoped_ptr<QuicPacket> packet(
+ std::unique_ptr<QuicPacket> packet(
BuildUnsizedDataPacket(&framer, header, frames));
char buffer[kMaxPacketSize];
size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
@@ -508,7 +515,7 @@
buffer, kMaxPacketSize);
EXPECT_NE(0u, encrypted_size);
QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
- return scoped_ptr<QuicReceivedPacket>(encrypted.Clone());
+ return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
}
void QuicTestPacketMaker::InitializeHeader(QuicPacketNumber packet_number,
diff --git a/net/quic/test_tools/quic_test_packet_maker.h b/net/quic/test_tools/quic_test_packet_maker.h
index 3574ab7..e60ab3c 100644
--- a/net/quic/test_tools/quic_test_packet_maker.h
+++ b/net/quic/test_tools/quic_test_packet_maker.h
@@ -9,8 +9,9 @@
#include <stddef.h>
+#include <memory>
+
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "net/base/request_priority.h"
#include "net/quic/quic_protocol.h"
#include "net/quic/test_tools/mock_clock.h"
@@ -30,22 +31,22 @@
~QuicTestPacketMaker();
void set_hostname(const std::string& host);
- scoped_ptr<QuicReceivedPacket> MakePingPacket(QuicPacketNumber num,
- bool include_version);
- scoped_ptr<QuicReceivedPacket> MakeRstPacket(
+ std::unique_ptr<QuicReceivedPacket> MakePingPacket(QuicPacketNumber num,
+ bool include_version);
+ std::unique_ptr<QuicReceivedPacket> MakeRstPacket(
QuicPacketNumber num,
bool include_version,
QuicStreamId stream_id,
QuicRstStreamErrorCode error_code);
- scoped_ptr<QuicReceivedPacket> MakeRstPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeRstPacket(
QuicPacketNumber num,
bool include_version,
QuicStreamId stream_id,
QuicRstStreamErrorCode error_code,
size_t bytes_written);
- scoped_ptr<QuicReceivedPacket> MakeAckAndRstPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeAckAndRstPacket(
QuicPacketNumber num,
bool include_version,
QuicStreamId stream_id,
@@ -54,7 +55,7 @@
QuicPacketNumber ack_least_unacked,
QuicPacketNumber stop_least_unacked,
bool send_feedback);
- scoped_ptr<QuicReceivedPacket> MakeAckAndConnectionClosePacket(
+ std::unique_ptr<QuicReceivedPacket> MakeAckAndConnectionClosePacket(
QuicPacketNumber num,
bool include_version,
QuicTime::Delta delta_time_largest_observed,
@@ -62,29 +63,31 @@
QuicPacketNumber least_unacked,
QuicErrorCode quic_error,
std::string& quic_error_details);
- scoped_ptr<QuicReceivedPacket> MakeConnectionClosePacket(
+ std::unique_ptr<QuicReceivedPacket> MakeConnectionClosePacket(
QuicPacketNumber num);
- scoped_ptr<QuicReceivedPacket> MakeGoAwayPacket(QuicPacketNumber num,
- QuicErrorCode error_code,
- std::string reason_phrase);
- scoped_ptr<QuicReceivedPacket> MakeAckPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeGoAwayPacket(
+ QuicPacketNumber num,
+ QuicErrorCode error_code,
+ std::string reason_phrase);
+ std::unique_ptr<QuicReceivedPacket> MakeAckPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber least_unacked,
bool send_feedback);
- scoped_ptr<QuicReceivedPacket> MakeAckPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeAckPacket(
QuicPacketNumber packet_number,
QuicPacketNumber largest_received,
QuicPacketNumber ack_least_unacked,
QuicPacketNumber stop_least_unacked,
bool send_feedback);
- scoped_ptr<QuicReceivedPacket> MakeDataPacket(QuicPacketNumber packet_number,
- QuicStreamId stream_id,
- bool should_include_version,
- bool fin,
- QuicStreamOffset offset,
- base::StringPiece data);
- scoped_ptr<QuicReceivedPacket> MakeAckAndDataPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeDataPacket(
+ QuicPacketNumber packet_number,
+ QuicStreamId stream_id,
+ bool should_include_version,
+ bool fin,
+ QuicStreamOffset offset,
+ base::StringPiece data);
+ std::unique_ptr<QuicReceivedPacket> MakeAckAndDataPacket(
QuicPacketNumber packet_number,
bool include_version,
QuicStreamId stream_id,
@@ -96,7 +99,7 @@
// If |spdy_headers_frame_length| is non-null, it will be set to the size of
// the SPDY headers frame created for this packet.
- scoped_ptr<QuicReceivedPacket> MakeRequestHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -105,7 +108,7 @@
const SpdyHeaderBlock& headers,
size_t* spdy_headers_frame_length);
- scoped_ptr<QuicReceivedPacket> MakeRequestHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeRequestHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -117,18 +120,18 @@
// Convenience method for calling MakeRequestHeadersPacket with nullptr for
// |spdy_headers_frame_length|.
- scoped_ptr<QuicReceivedPacket> MakeRequestHeadersPacketWithOffsetTracking(
- QuicPacketNumber packet_number,
- QuicStreamId stream_id,
- bool should_include_version,
- bool fin,
- SpdyPriority priority,
- const SpdyHeaderBlock& headers,
- QuicStreamOffset* offset);
+ std::unique_ptr<QuicReceivedPacket>
+ MakeRequestHeadersPacketWithOffsetTracking(QuicPacketNumber packet_number,
+ QuicStreamId stream_id,
+ bool should_include_version,
+ bool fin,
+ SpdyPriority priority,
+ const SpdyHeaderBlock& headers,
+ QuicStreamOffset* offset);
// If |spdy_headers_frame_length| is non-null, it will be set to the size of
// the SPDY headers frame created for this packet.
- scoped_ptr<QuicReceivedPacket> MakeResponseHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -137,7 +140,7 @@
size_t* spdy_headers_frame_length,
QuicStreamOffset* offset);
- scoped_ptr<QuicReceivedPacket> MakeResponseHeadersPacket(
+ std::unique_ptr<QuicReceivedPacket> MakeResponseHeadersPacket(
QuicPacketNumber packet_number,
QuicStreamId stream_id,
bool should_include_version,
@@ -147,13 +150,13 @@
// Convenience method for calling MakeResponseHeadersPacket with nullptr for
// |spdy_headers_frame_length|.
- scoped_ptr<QuicReceivedPacket> MakeResponseHeadersPacketWithOffsetTracking(
- QuicPacketNumber packet_number,
- QuicStreamId stream_id,
- bool should_include_version,
- bool fin,
- const SpdyHeaderBlock& headers,
- QuicStreamOffset* offset);
+ std::unique_ptr<QuicReceivedPacket>
+ MakeResponseHeadersPacketWithOffsetTracking(QuicPacketNumber packet_number,
+ QuicStreamId stream_id,
+ bool should_include_version,
+ bool fin,
+ const SpdyHeaderBlock& headers,
+ QuicStreamOffset* offset);
SpdyHeaderBlock GetRequestHeaders(const std::string& method,
const std::string& scheme,
@@ -164,9 +167,9 @@
const std::string& alt_svc);
private:
- scoped_ptr<QuicReceivedPacket> MakePacket(const QuicPacketHeader& header,
- const QuicFrame& frame);
- scoped_ptr<QuicReceivedPacket> MakeMultipleFramesPacket(
+ std::unique_ptr<QuicReceivedPacket> MakePacket(const QuicPacketHeader& header,
+ const QuicFrame& frame);
+ std::unique_ptr<QuicReceivedPacket> MakeMultipleFramesPacket(
const QuicPacketHeader& header,
const QuicFrames& frames);
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index 3d9267a..5fd9d7de 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -535,7 +535,7 @@
QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(),
QuicTime::Zero(), Perspective::IS_CLIENT);
- scoped_ptr<QuicPacket> packet(
+ std::unique_ptr<QuicPacket> packet(
BuildUnsizedDataPacket(&framer, header, frames));
EXPECT_TRUE(packet != nullptr);
char* buffer = new char[kMaxPacketSize];
@@ -586,7 +586,7 @@
QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(),
QuicTime::Zero(), Perspective::IS_CLIENT);
- scoped_ptr<QuicPacket> packet(
+ std::unique_ptr<QuicPacket> packet(
BuildUnsizedDataPacket(&framer, header, frames));
EXPECT_TRUE(packet != nullptr);
@@ -611,7 +611,7 @@
EXPECT_EQ(actual_len, expected_len);
const int min_len = min(actual_len, expected_len);
const int max_len = max(actual_len, expected_len);
- scoped_ptr<bool[]> marks(new bool[max_len]);
+ std::unique_ptr<bool[]> marks(new bool[max_len]);
bool identical = (actual_len == expected_len);
for (int i = 0; i < min_len; ++i) {
if (actual[i] != expected[i]) {
@@ -651,7 +651,8 @@
const CryptoHandshakeMessage& message,
bool should_include_version) {
CryptoFramer crypto_framer;
- scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
+ std::unique_ptr<QuicData> data(
+ crypto_framer.ConstructHandshakeMessage(message));
QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(),
Perspective::IS_CLIENT);
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index 87889f7..83a800e 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -513,7 +513,7 @@
QuicAckListenerInterface* ack_notifier_delegate);
private:
- scoped_ptr<QuicCryptoStream> crypto_stream_;
+ std::unique_ptr<QuicCryptoStream> crypto_stream_;
DISALLOW_COPY_AND_ASSIGN(MockQuicSpdySession);
};
@@ -567,7 +567,7 @@
QuicCryptoClientStream* GetCryptoStream() override;
private:
- scoped_ptr<QuicCryptoClientStream> crypto_stream_;
+ std::unique_ptr<QuicCryptoClientStream> crypto_stream_;
QuicClientPushPromiseIndex push_promise_index_;
DISALLOW_COPY_AND_ASSIGN(TestQuicSpdyClientSession);
diff --git a/net/quic/test_tools/simple_quic_framer.cc b/net/quic/test_tools/simple_quic_framer.cc
index dd0e0cb..62e74b61 100644
--- a/net/quic/test_tools/simple_quic_framer.cc
+++ b/net/quic/test_tools/simple_quic_framer.cc
@@ -137,8 +137,8 @@
QuicErrorCode error_;
bool has_header_;
QuicPacketHeader header_;
- scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
- scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
+ std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
+ std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
vector<QuicAckFrame> ack_frames_;
vector<QuicStopWaitingFrame> stop_waiting_frames_;
vector<QuicPingFrame> ping_frames_;
diff --git a/net/quic/test_tools/simple_quic_framer.h b/net/quic/test_tools/simple_quic_framer.h
index f09db61..bfc4761 100644
--- a/net/quic/test_tools/simple_quic_framer.h
+++ b/net/quic/test_tools/simple_quic_framer.h
@@ -7,10 +7,10 @@
#include <stddef.h>
+#include <memory>
#include <vector>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/quic/quic_framer.h"
#include "net/quic/quic_protocol.h"
@@ -56,7 +56,7 @@
private:
QuicFramer framer_;
- scoped_ptr<SimpleFramerVisitor> visitor_;
+ std::unique_ptr<SimpleFramerVisitor> visitor_;
DISALLOW_COPY_AND_ASSIGN(SimpleQuicFramer);
};
diff --git a/net/tools/quic/quic_time_wait_list_manager.h b/net/tools/quic/quic_time_wait_list_manager.h
index 52e1d62..d29910fb 100644
--- a/net/tools/quic/quic_time_wait_list_manager.h
+++ b/net/tools/quic/quic_time_wait_list_manager.h
@@ -12,6 +12,7 @@
#include <stddef.h>
#include <deque>
+#include <memory>
#include "base/macros.h"
#include "net/base/linked_hash_map.h"
@@ -182,7 +183,7 @@
// Alarm to clean up connection_ids that have out lived their duration in
// time wait state.
- scoped_ptr<QuicAlarm> connection_id_clean_up_alarm_;
+ std::unique_ptr<QuicAlarm> connection_id_clean_up_alarm_;
// Clock to efficiently measure approximate time.
const QuicClock* clock_;
