summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--net/socket/client_socket_pool_manager.cc2
-rw-r--r--net/socket/server_socket.h2
-rw-r--r--net/socket/ssl_client_socket_nss.cc2
-rw-r--r--net/socket/ssl_client_socket_openssl_unittest.cc10
-rw-r--r--net/socket/ssl_server_socket_unittest.cc150
-rw-r--r--net/socket/tcp_server_socket_unittest.cc8
-rw-r--r--net/socket/transport_client_socket_pool_unittest.cc2
-rw-r--r--net/socket/websocket_transport_client_socket_pool_unittest.cc2
8 files changed, 88 insertions, 90 deletions
diff --git a/net/socket/client_socket_pool_manager.cc b/net/socket/client_socket_pool_manager.cc
index f81b4bc..a7bf1fe 100644
--- a/net/socket/client_socket_pool_manager.cc
+++ b/net/socket/client_socket_pool_manager.cc
@@ -132,7 +132,7 @@ int InitSocketPoolHelper(const GURL& request_url,
// should be the same for all connections, whereas version_max may
// change for version fallbacks.
std::string prefix = "ssl/";
- if (ssl_config_for_origin.version_max != net::kDefaultSSLVersionMax) {
+ if (ssl_config_for_origin.version_max != kDefaultSSLVersionMax) {
switch (ssl_config_for_origin.version_max) {
case SSL_PROTOCOL_VERSION_TLS1_2:
prefix = "ssl(max:3.3)/";
diff --git a/net/socket/server_socket.h b/net/socket/server_socket.h
index 9f87eea..528955b 100644
--- a/net/socket/server_socket.h
+++ b/net/socket/server_socket.h
@@ -23,7 +23,7 @@ class NET_EXPORT ServerSocket {
// Binds the socket and starts listening. Destroy the socket to stop
// listening.
- virtual int Listen(const net::IPEndPoint& address, int backlog) = 0;
+ virtual int Listen(const IPEndPoint& address, int backlog) = 0;
// Binds the socket with address and port, and starts listening. It expects
// a valid IPv4 or IPv6 address. Otherwise, it returns ERR_ADDRESS_INVALID.
diff --git a/net/socket/ssl_client_socket_nss.cc b/net/socket/ssl_client_socket_nss.cc
index 6eca964..dcb4c1e 100644
--- a/net/socket/ssl_client_socket_nss.cc
+++ b/net/socket/ssl_client_socket_nss.cc
@@ -1801,7 +1801,7 @@ int SSLClientSocketNSS::Core::DoWriteLoop(int result) {
int SSLClientSocketNSS::Core::DoHandshake() {
DCHECK(OnNSSTaskRunner());
- int net_error = net::OK;
+ int net_error = OK;
SECStatus rv = SSL_ForceHandshake(nss_fd_);
// Note: this function may be called multiple times during the handshake, so
diff --git a/net/socket/ssl_client_socket_openssl_unittest.cc b/net/socket/ssl_client_socket_openssl_unittest.cc
index f89bae9..513188b 100644
--- a/net/socket/ssl_client_socket_openssl_unittest.cc
+++ b/net/socket/ssl_client_socket_openssl_unittest.cc
@@ -85,13 +85,13 @@ bool LoadPrivateKeyOpenSSL(
class SSLClientSocketOpenSSLClientAuthTest : public PlatformTest {
public:
SSLClientSocketOpenSSLClientAuthTest()
- : socket_factory_(net::ClientSocketFactory::GetDefaultFactory()),
- cert_verifier_(new net::MockCertVerifier),
- transport_security_state_(new net::TransportSecurityState) {
- cert_verifier_->set_default_result(net::OK);
+ : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
+ cert_verifier_(new MockCertVerifier),
+ transport_security_state_(new TransportSecurityState) {
+ cert_verifier_->set_default_result(OK);
context_.cert_verifier = cert_verifier_.get();
context_.transport_security_state = transport_security_state_.get();
- key_store_ = net::OpenSSLClientKeyStore::GetInstance();
+ key_store_ = OpenSSLClientKeyStore::GetInstance();
}
virtual ~SSLClientSocketOpenSSLClientAuthTest() {
diff --git a/net/socket/ssl_server_socket_unittest.cc b/net/socket/ssl_server_socket_unittest.cc
index 5b82fcf..79d5a7f 100644
--- a/net/socket/ssl_server_socket_unittest.cc
+++ b/net/socket/ssl_server_socket_unittest.cc
@@ -70,7 +70,7 @@ class FakeDataChannel {
read_callback_ = callback;
read_buf_ = buf;
read_buf_len_ = buf_len;
- return net::ERR_IO_PENDING;
+ return ERR_IO_PENDING;
}
return PropogateData(buf, buf_len);
}
@@ -79,17 +79,17 @@ class FakeDataChannel {
DCHECK(write_callback_.is_null());
if (closed_) {
if (write_called_after_close_)
- return net::ERR_CONNECTION_RESET;
+ return ERR_CONNECTION_RESET;
write_called_after_close_ = true;
write_callback_ = callback;
base::MessageLoop::current()->PostTask(
FROM_HERE, base::Bind(&FakeDataChannel::DoWriteCallback,
weak_factory_.GetWeakPtr()));
- return net::ERR_IO_PENDING;
+ return ERR_IO_PENDING;
}
// This function returns synchronously, so make a copy of the buffer.
- data_.push(new net::DrainableIOBuffer(
- new net::StringIOBuffer(std::string(buf->data(), buf_len)),
+ data_.push(new DrainableIOBuffer(
+ new StringIOBuffer(std::string(buf->data(), buf_len)),
buf_len));
base::MessageLoop::current()->PostTask(
FROM_HERE, base::Bind(&FakeDataChannel::DoReadCallback,
@@ -124,11 +124,11 @@ class FakeDataChannel {
CompletionCallback callback = write_callback_;
write_callback_.Reset();
- callback.Run(net::ERR_CONNECTION_RESET);
+ callback.Run(ERR_CONNECTION_RESET);
}
- int PropogateData(scoped_refptr<net::IOBuffer> read_buf, int read_buf_len) {
- scoped_refptr<net::DrainableIOBuffer> buf = data_.front();
+ int PropogateData(scoped_refptr<IOBuffer> read_buf, int read_buf_len) {
+ scoped_refptr<DrainableIOBuffer> buf = data_.front();
int copied = std::min(buf->BytesRemaining(), read_buf_len);
memcpy(read_buf->data(), buf->data(), copied);
buf->DidConsume(copied);
@@ -139,12 +139,12 @@ class FakeDataChannel {
}
CompletionCallback read_callback_;
- scoped_refptr<net::IOBuffer> read_buf_;
+ scoped_refptr<IOBuffer> read_buf_;
int read_buf_len_;
CompletionCallback write_callback_;
- std::queue<scoped_refptr<net::DrainableIOBuffer> > data_;
+ std::queue<scoped_refptr<DrainableIOBuffer> > data_;
// True if Close() has been called.
bool closed_;
@@ -185,15 +185,15 @@ class FakeSocket : public StreamSocket {
}
virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
- return net::OK;
+ return OK;
}
virtual int SetSendBufferSize(int32 size) OVERRIDE {
- return net::OK;
+ return OK;
}
virtual int Connect(const CompletionCallback& callback) OVERRIDE {
- return net::OK;
+ return OK;
}
virtual void Disconnect() OVERRIDE {
@@ -210,15 +210,15 @@ class FakeSocket : public StreamSocket {
}
virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
- net::IPAddressNumber ip_address(net::kIPv4AddressSize);
- *address = net::IPEndPoint(ip_address, 0 /*port*/);
- return net::OK;
+ IPAddressNumber ip_address(kIPv4AddressSize);
+ *address = IPEndPoint(ip_address, 0 /*port*/);
+ return OK;
}
virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
- net::IPAddressNumber ip_address(4);
- *address = net::IPEndPoint(ip_address, 0);
- return net::OK;
+ IPAddressNumber ip_address(4);
+ *address = IPEndPoint(ip_address, 0);
+ return OK;
}
virtual const BoundNetLog& NetLog() const OVERRIDE {
@@ -250,7 +250,7 @@ class FakeSocket : public StreamSocket {
}
private:
- net::BoundNetLog net_log_;
+ BoundNetLog net_log_;
FakeDataChannel* incoming_;
FakeDataChannel* outgoing_;
@@ -270,8 +270,8 @@ TEST(FakeSocketTest, DataTransfer) {
const char kTestData[] = "testing123";
const int kTestDataSize = strlen(kTestData);
const int kReadBufSize = 1024;
- scoped_refptr<net::IOBuffer> write_buf = new net::StringIOBuffer(kTestData);
- scoped_refptr<net::IOBuffer> read_buf = new net::IOBuffer(kReadBufSize);
+ scoped_refptr<IOBuffer> write_buf = new StringIOBuffer(kTestData);
+ scoped_refptr<IOBuffer> read_buf = new IOBuffer(kReadBufSize);
// Write then read.
int written =
@@ -286,7 +286,7 @@ TEST(FakeSocketTest, DataTransfer) {
// Read then write.
TestCompletionCallback callback;
- EXPECT_EQ(net::ERR_IO_PENDING,
+ EXPECT_EQ(ERR_IO_PENDING,
server.Read(read_buf.get(), kReadBufSize, callback.callback()));
written = client.Write(write_buf.get(), kTestDataSize, CompletionCallback());
@@ -302,10 +302,10 @@ TEST(FakeSocketTest, DataTransfer) {
class SSLServerSocketTest : public PlatformTest {
public:
SSLServerSocketTest()
- : socket_factory_(net::ClientSocketFactory::GetDefaultFactory()),
+ : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
cert_verifier_(new MockCertVerifier()),
transport_security_state_(new TransportSecurityState) {
- cert_verifier_->set_default_result(net::CERT_STATUS_AUTHORITY_INVALID);
+ cert_verifier_->set_default_result(CERT_STATUS_AUTHORITY_INVALID);
}
protected:
@@ -322,7 +322,7 @@ class SSLServerSocketTest : public PlatformTest {
std::string cert_der;
ASSERT_TRUE(base::ReadFileToString(cert_path, &cert_der));
- scoped_refptr<net::X509Certificate> cert =
+ scoped_refptr<X509Certificate> cert =
X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
base::FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
@@ -336,35 +336,35 @@ class SSLServerSocketTest : public PlatformTest {
scoped_ptr<crypto::RSAPrivateKey> private_key(
crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
- net::SSLConfig ssl_config;
+ SSLConfig ssl_config;
ssl_config.false_start_enabled = false;
ssl_config.channel_id_enabled = false;
// Certificate provided by the host doesn't need authority.
- net::SSLConfig::CertAndStatus cert_and_status;
+ SSLConfig::CertAndStatus cert_and_status;
cert_and_status.cert_status = CERT_STATUS_AUTHORITY_INVALID;
cert_and_status.der_cert = cert_der;
ssl_config.allowed_bad_certs.push_back(cert_and_status);
- net::HostPortPair host_and_pair("unittest", 0);
- net::SSLClientSocketContext context;
+ HostPortPair host_and_pair("unittest", 0);
+ SSLClientSocketContext context;
context.cert_verifier = cert_verifier_.get();
context.transport_security_state = transport_security_state_.get();
client_socket_ =
socket_factory_->CreateSSLClientSocket(
client_connection.Pass(), host_and_pair, ssl_config, context);
- server_socket_ = net::CreateSSLServerSocket(
+ server_socket_ = CreateSSLServerSocket(
server_socket.Pass(),
- cert.get(), private_key.get(), net::SSLConfig());
+ cert.get(), private_key.get(), SSLConfig());
}
FakeDataChannel channel_1_;
FakeDataChannel channel_2_;
- scoped_ptr<net::SSLClientSocket> client_socket_;
- scoped_ptr<net::SSLServerSocket> server_socket_;
- net::ClientSocketFactory* socket_factory_;
- scoped_ptr<net::MockCertVerifier> cert_verifier_;
- scoped_ptr<net::TransportSecurityState> transport_security_state_;
+ scoped_ptr<SSLClientSocket> client_socket_;
+ scoped_ptr<SSLServerSocket> server_socket_;
+ ClientSocketFactory* socket_factory_;
+ scoped_ptr<MockCertVerifier> cert_verifier_;
+ scoped_ptr<TransportSecurityState> transport_security_state_;
};
// This test only executes creation of client and server sockets. This is to
@@ -384,16 +384,16 @@ TEST_F(SSLServerSocketTest, Handshake) {
TestCompletionCallback handshake_callback;
int server_ret = server_socket_->Handshake(handshake_callback.callback());
- EXPECT_TRUE(server_ret == net::OK || server_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
int client_ret = client_socket_->Connect(connect_callback.callback());
- EXPECT_TRUE(client_ret == net::OK || client_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
- if (client_ret == net::ERR_IO_PENDING) {
- EXPECT_EQ(net::OK, connect_callback.WaitForResult());
+ if (client_ret == ERR_IO_PENDING) {
+ EXPECT_EQ(OK, connect_callback.WaitForResult());
}
- if (server_ret == net::ERR_IO_PENDING) {
- EXPECT_EQ(net::OK, handshake_callback.WaitForResult());
+ if (server_ret == ERR_IO_PENDING) {
+ EXPECT_EQ(OK, handshake_callback.WaitForResult());
}
// Make sure the cert status is expected.
@@ -410,32 +410,31 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
// Establish connection.
int client_ret = client_socket_->Connect(connect_callback.callback());
- ASSERT_TRUE(client_ret == net::OK || client_ret == net::ERR_IO_PENDING);
+ ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
int server_ret = server_socket_->Handshake(handshake_callback.callback());
- ASSERT_TRUE(server_ret == net::OK || server_ret == net::ERR_IO_PENDING);
+ ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
client_ret = connect_callback.GetResult(client_ret);
- ASSERT_EQ(net::OK, client_ret);
+ ASSERT_EQ(OK, client_ret);
server_ret = handshake_callback.GetResult(server_ret);
- ASSERT_EQ(net::OK, server_ret);
+ ASSERT_EQ(OK, server_ret);
const int kReadBufSize = 1024;
- scoped_refptr<net::StringIOBuffer> write_buf =
- new net::StringIOBuffer("testing123");
- scoped_refptr<net::DrainableIOBuffer> read_buf =
- new net::DrainableIOBuffer(new net::IOBuffer(kReadBufSize),
- kReadBufSize);
+ scoped_refptr<StringIOBuffer> write_buf =
+ new StringIOBuffer("testing123");
+ scoped_refptr<DrainableIOBuffer> read_buf =
+ new DrainableIOBuffer(new IOBuffer(kReadBufSize), kReadBufSize);
// Write then read.
TestCompletionCallback write_callback;
TestCompletionCallback read_callback;
server_ret = server_socket_->Write(
write_buf.get(), write_buf->size(), write_callback.callback());
- EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(server_ret > 0 || server_ret == ERR_IO_PENDING);
client_ret = client_socket_->Read(
read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
- EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
server_ret = write_callback.GetResult(server_ret);
EXPECT_GT(server_ret, 0);
@@ -446,7 +445,7 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
while (read_buf->BytesConsumed() < write_buf->size()) {
client_ret = client_socket_->Read(
read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
- EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
client_ret = read_callback.GetResult(client_ret);
ASSERT_GT(client_ret, 0);
read_buf->DidConsume(client_ret);
@@ -456,13 +455,13 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
EXPECT_EQ(0, memcmp(write_buf->data(), read_buf->data(), write_buf->size()));
// Read then write.
- write_buf = new net::StringIOBuffer("hello123");
+ write_buf = new StringIOBuffer("hello123");
server_ret = server_socket_->Read(
read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
- EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(server_ret > 0 || server_ret == ERR_IO_PENDING);
client_ret = client_socket_->Write(
write_buf.get(), write_buf->size(), write_callback.callback());
- EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
server_ret = read_callback.GetResult(server_ret);
ASSERT_GT(server_ret, 0);
@@ -473,7 +472,7 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
while (read_buf->BytesConsumed() < write_buf->size()) {
server_ret = server_socket_->Read(
read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
- EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(server_ret > 0 || server_ret == ERR_IO_PENDING);
server_ret = read_callback.GetResult(server_ret);
ASSERT_GT(server_ret, 0);
read_buf->DidConsume(server_ret);
@@ -495,18 +494,17 @@ TEST_F(SSLServerSocketTest, ClientWriteAfterServerClose) {
// Establish connection.
int client_ret = client_socket_->Connect(connect_callback.callback());
- ASSERT_TRUE(client_ret == net::OK || client_ret == net::ERR_IO_PENDING);
+ ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
int server_ret = server_socket_->Handshake(handshake_callback.callback());
- ASSERT_TRUE(server_ret == net::OK || server_ret == net::ERR_IO_PENDING);
+ ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
client_ret = connect_callback.GetResult(client_ret);
- ASSERT_EQ(net::OK, client_ret);
+ ASSERT_EQ(OK, client_ret);
server_ret = handshake_callback.GetResult(server_ret);
- ASSERT_EQ(net::OK, server_ret);
+ ASSERT_EQ(OK, server_ret);
- scoped_refptr<net::StringIOBuffer> write_buf =
- new net::StringIOBuffer("testing123");
+ scoped_refptr<StringIOBuffer> write_buf = new StringIOBuffer("testing123");
// The server closes the connection. The server needs to write some
// data first so that the client's Read() calls from the transport
@@ -516,7 +514,7 @@ TEST_F(SSLServerSocketTest, ClientWriteAfterServerClose) {
server_ret = server_socket_->Write(
write_buf.get(), write_buf->size(), write_callback.callback());
- EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(server_ret > 0 || server_ret == ERR_IO_PENDING);
server_ret = write_callback.GetResult(server_ret);
EXPECT_GT(server_ret, 0);
@@ -526,7 +524,7 @@ TEST_F(SSLServerSocketTest, ClientWriteAfterServerClose) {
// The client writes some data. This should not cause an infinite loop.
client_ret = client_socket_->Write(
write_buf.get(), write_buf->size(), write_callback.callback());
- EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
+ EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
client_ret = write_callback.GetResult(client_ret);
EXPECT_GT(client_ret, 0);
@@ -547,16 +545,16 @@ TEST_F(SSLServerSocketTest, ExportKeyingMaterial) {
TestCompletionCallback handshake_callback;
int client_ret = client_socket_->Connect(connect_callback.callback());
- ASSERT_TRUE(client_ret == net::OK || client_ret == net::ERR_IO_PENDING);
+ ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
int server_ret = server_socket_->Handshake(handshake_callback.callback());
- ASSERT_TRUE(server_ret == net::OK || server_ret == net::ERR_IO_PENDING);
+ ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
- if (client_ret == net::ERR_IO_PENDING) {
- ASSERT_EQ(net::OK, connect_callback.WaitForResult());
+ if (client_ret == ERR_IO_PENDING) {
+ ASSERT_EQ(OK, connect_callback.WaitForResult());
}
- if (server_ret == net::ERR_IO_PENDING) {
- ASSERT_EQ(net::OK, handshake_callback.WaitForResult());
+ if (server_ret == ERR_IO_PENDING) {
+ ASSERT_EQ(OK, handshake_callback.WaitForResult());
}
const int kKeyingMaterialSize = 32;
@@ -566,13 +564,13 @@ TEST_F(SSLServerSocketTest, ExportKeyingMaterial) {
int rv = server_socket_->ExportKeyingMaterial(kKeyingLabel,
false, kKeyingContext,
server_out, sizeof(server_out));
- ASSERT_EQ(net::OK, rv);
+ ASSERT_EQ(OK, rv);
unsigned char client_out[kKeyingMaterialSize];
rv = client_socket_->ExportKeyingMaterial(kKeyingLabel,
false, kKeyingContext,
client_out, sizeof(client_out));
- ASSERT_EQ(net::OK, rv);
+ ASSERT_EQ(OK, rv);
EXPECT_EQ(0, memcmp(server_out, client_out, sizeof(server_out)));
const char* kKeyingLabelBad = "EXPERIMENTAL-server-socket-test-bad";
@@ -580,7 +578,7 @@ TEST_F(SSLServerSocketTest, ExportKeyingMaterial) {
rv = client_socket_->ExportKeyingMaterial(kKeyingLabelBad,
false, kKeyingContext,
client_bad, sizeof(client_bad));
- ASSERT_EQ(rv, net::OK);
+ ASSERT_EQ(rv, OK);
EXPECT_NE(0, memcmp(server_out, client_bad, sizeof(server_out)));
}
diff --git a/net/socket/tcp_server_socket_unittest.cc b/net/socket/tcp_server_socket_unittest.cc
index fd81e55..01bae9f 100644
--- a/net/socket/tcp_server_socket_unittest.cc
+++ b/net/socket/tcp_server_socket_unittest.cc
@@ -215,8 +215,8 @@ TEST_F(TCPServerSocketTest, AcceptIO) {
size_t bytes_written = 0;
while (bytes_written < message.size()) {
- scoped_refptr<net::IOBufferWithSize> write_buffer(
- new net::IOBufferWithSize(message.size() - bytes_written));
+ scoped_refptr<IOBufferWithSize> write_buffer(
+ new IOBufferWithSize(message.size() - bytes_written));
memmove(write_buffer->data(), message.data(), message.size());
TestCompletionCallback write_callback;
@@ -230,8 +230,8 @@ TEST_F(TCPServerSocketTest, AcceptIO) {
size_t bytes_read = 0;
while (bytes_read < message.size()) {
- scoped_refptr<net::IOBufferWithSize> read_buffer(
- new net::IOBufferWithSize(message.size() - bytes_read));
+ scoped_refptr<IOBufferWithSize> read_buffer(
+ new IOBufferWithSize(message.size() - bytes_read));
TestCompletionCallback read_callback;
int read_result = connecting_socket.Read(
read_buffer.get(), read_buffer->size(), read_callback.callback());
diff --git a/net/socket/transport_client_socket_pool_unittest.cc b/net/socket/transport_client_socket_pool_unittest.cc
index 1d2b99e..1cc015a 100644
--- a/net/socket/transport_client_socket_pool_unittest.cc
+++ b/net/socket/transport_client_socket_pool_unittest.cc
@@ -32,7 +32,7 @@ namespace {
const int kMaxSockets = 32;
const int kMaxSocketsPerGroup = 6;
-const net::RequestPriority kDefaultPriority = LOW;
+const RequestPriority kDefaultPriority = LOW;
class TransportClientSocketPoolTest : public testing::Test {
protected:
diff --git a/net/socket/websocket_transport_client_socket_pool_unittest.cc b/net/socket/websocket_transport_client_socket_pool_unittest.cc
index e61c9f4..7c7677a 100644
--- a/net/socket/websocket_transport_client_socket_pool_unittest.cc
+++ b/net/socket/websocket_transport_client_socket_pool_unittest.cc
@@ -37,7 +37,7 @@ namespace {
const int kMaxSockets = 32;
const int kMaxSocketsPerGroup = 6;
-const net::RequestPriority kDefaultPriority = LOW;
+const RequestPriority kDefaultPriority = LOW;
// RunLoop doesn't support this natively but it is easy to emulate.
void RunLoopForTimePeriod(base::TimeDelta period) {
generated by cgit v1.1 at 2025-05-13 10:51:37 +0000