An implementation of chrome.socket.secure().

chrome/browser/extensions/api/socket/tls_socket_unittest.cc

Index: chrome/browser/extensions/api/socket/tls_socket_unittest.cc
diff --git a/chrome/browser/extensions/api/socket/tls_socket_unittest.cc b/chrome/browser/extensions/api/socket/tls_socket_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c4ccc76e0ea103680e3e3a004b37d40b47ebc7c4
--- /dev/null
+++ b/chrome/browser/extensions/api/socket/tls_socket_unittest.cc
@@ -0,0 +1,204 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/extensions/api/socket/tls_socket.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string_piece.h"
+#include "net/base/address_list.h"
+#include "net/base/completion_callback.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/rand_callback.h"
+#include "net/socket/ssl_client_socket.h"
+#include "net/socket/tcp_client_socket.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+using testing::_;
+using testing::DoAll;
+using testing::Return;
+using testing::SaveArg;
+using base::StringPiece;
+
+namespace net {
+class ServerBoundCertService;
+}
+
+namespace extensions {
+
+class MockSSLClientSocket : public net::SSLClientSocket {
+ public:
+  MockSSLClientSocket() {}
+  MOCK_METHOD0(Disconnect, void());
+  MOCK_METHOD3(Read,
+               int(net::IOBuffer* buf,
+                   int buf_len,
+                   const net::CompletionCallback& callback));
+  MOCK_METHOD3(Write,
+               int(net::IOBuffer* buf,
+                   int buf_len,
+                   const net::CompletionCallback& callback));
+  MOCK_METHOD1(SetReceiveBufferSize, bool(int32));
+  MOCK_METHOD1(SetSendBufferSize, bool(int32));
+  MOCK_METHOD1(Connect, int(const CompletionCallback&));
+  MOCK_CONST_METHOD0(IsConnectedAndIdle, bool());
+  MOCK_CONST_METHOD1(GetPeerAddress, int(net::IPEndPoint*));
+  MOCK_CONST_METHOD1(GetLocalAddress, int(net::IPEndPoint*));
+  MOCK_CONST_METHOD0(NetLog, const net::BoundNetLog&());
+  MOCK_METHOD0(SetSubresourceSpeculation, void());
+  MOCK_METHOD0(SetOmniboxSpeculation, void());
+  MOCK_CONST_METHOD0(WasEverUsed, bool());
+  MOCK_CONST_METHOD0(UsingTCPFastOpen, bool());
+  MOCK_METHOD1(GetSSLInfo, bool(net::SSLInfo*));
+  MOCK_METHOD5(ExportKeyingMaterial,
+               int(const StringPiece&,
+                   bool,
+                   const StringPiece&,
+                   unsigned char*,
+                   unsigned int));
+  MOCK_METHOD1(GetTLSUniqueChannelBinding, int(std::string*));
+  MOCK_METHOD1(GetSSLCertRequestInfo, void(net::SSLCertRequestInfo*));
+  MOCK_METHOD2(GetNextProto,
+               net::SSLClientSocket::NextProtoStatus(std::string*,
+                                                     std::string*));
+  MOCK_CONST_METHOD0(GetServerBoundCertService, net::ServerBoundCertService*());
+  virtual bool IsConnected() const OVERRIDE { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockSSLClientSocket);
+};
+
+class MockTCPSocket : public net::TCPClientSocket {
+ public:
+  explicit MockTCPSocket(const net::AddressList& address_list)
+      : net::TCPClientSocket(address_list, NULL, net::NetLog::Source()) {}
+
+  MOCK_METHOD3(Read,
+               int(net::IOBuffer* buf,
+                   int buf_len,
+                   const net::CompletionCallback& callback));
+  MOCK_METHOD3(Write,
+               int(net::IOBuffer* buf,
+                   int buf_len,
+                   const net::CompletionCallback& callback));
+  MOCK_METHOD2(SetKeepAlive, bool(bool enable, int delay));
+  MOCK_METHOD1(SetNoDelay, bool(bool no_delay));
+
+  virtual bool IsConnected() const OVERRIDE { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockTCPSocket);
+};
+
+class CompleteHandler {
+ public:
+  CompleteHandler() {}
+  MOCK_METHOD1(OnComplete, void(int result_code));
+  MOCK_METHOD2(OnReadComplete,
+               void(int result_code, scoped_refptr<net::IOBuffer> io_buffer));
+  MOCK_METHOD2(OnAccept, void(int, net::TCPClientSocket*));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
+};
+
+static const char FAKE_ID[] = "faktetesttlssocketunittest";
+
+TEST(SocketTest, TestTLSSocketRead) {

[Ryan Sleevi, 2014/02/24 20:06:49]

Can you add comments to each of these (eg: on line 107 / 125) that explains what
you're testing?

This is particularly important for the BlockedWrite/BlockedWriteReentry, as the
test is not entirely clear.

[lally, 2014/02/27 17:05:59]

Done.

+  net::AddressList address_list;
+  MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
+  MockSSLClientSocket* ssl_socket = new MockSSLClientSocket;
+  CompleteHandler handler;
+
+  scoped_ptr<TLSSocket> socket(
+      new TLSSocket(ssl_socket, tcp_client_socket, FAKE_ID));
+
+  EXPECT_CALL(*ssl_socket, Read(_, _, _)).Times(1);
+  EXPECT_CALL(handler, OnReadComplete(_, _)).Times(1);
+
+  const int count = 512;
+  socket->Read(
+      count,
+      base::Bind(&CompleteHandler::OnReadComplete, base::Unretained(&handler)));
+}
+
+TEST(SocketTest, TestTLSSocketWrite) {
+  net::AddressList address_list;
+  MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
+  MockSSLClientSocket* ssl_socket = new MockSSLClientSocket;
+  CompleteHandler handler;
+
+  scoped_ptr<TLSSocket> socket(
+      new TLSSocket(ssl_socket, tcp_client_socket, FAKE_ID));
+
+  net::CompletionCallback callback;
+  EXPECT_CALL(*ssl_socket, Write(_, _, _)).Times(2).WillRepeatedly(
+      testing::DoAll(SaveArg<2>(&callback), Return(128)));
+  EXPECT_CALL(handler, OnComplete(_)).Times(1);
+
+  scoped_refptr<net::IOBufferWithSize> io_buffer(
+      new net::IOBufferWithSize(256));
+  socket->Write(
+      io_buffer.get(),
+      io_buffer->size(),
+      base::Bind(&CompleteHandler::OnComplete, base::Unretained(&handler)));
+}
+
+TEST(SocketTest, TestTLSSocketBlockedWrite) {
+  net::AddressList address_list;
+  MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
+  MockSSLClientSocket* ssl_socket = new MockSSLClientSocket;
+  CompleteHandler handler;
+
+  scoped_ptr<TLSSocket> socket(
+      new TLSSocket(ssl_socket, tcp_client_socket, FAKE_ID));

[Ryan Sleevi, 2014/02/24 20:06:49]

Given the redundancy of this setup logic, does it make more sense to use a
TEST_F fixture instead?

[lally, 2014/02/27 17:05:59]

Good point. Done.

+
+  net::CompletionCallback callback;
+  EXPECT_CALL(*ssl_socket, Write(_, _, _)).Times(2).WillRepeatedly(
+      testing::DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
+  scoped_refptr<net::IOBufferWithSize> io_buffer(new net::IOBufferWithSize(42));
+  socket->Write(
+      io_buffer.get(),
+      io_buffer->size(),
+      base::Bind(&CompleteHandler::OnComplete, base::Unretained(&handler)));
+
+  // Good. Original call came back unable to complete. Now pretend the socket
+  // finished, and confirm that we passed the error back.
+  EXPECT_CALL(handler, OnComplete(42)).Times(1);
+  callback.Run(40);
+  callback.Run(2);
+}
+
+TEST(SocketTest, TestTLSSocketBlockedWriteReentry) {
+  net::AddressList address_list;
+  MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
+  MockSSLClientSocket* ssl_socket = new MockSSLClientSocket;
+  CompleteHandler handlers[5];

[Ryan Sleevi, 2014/02/24 20:06:49]

magic numbers: What exists to guarantee that this line, line 185, line 187, and
line 199 are kept in sync?

Seems like you can use a static const int kSomethingOrOther = 5; here within the
function.

And/or update lines 187/200 to use ARRAY_SIZE or the like.

And it's not clear why line 183 is .Times(5), when the other tests are .Times(2)
for a single test (eg: 158/152, 136/130)

[lally, 2014/02/27 17:05:59]

Documentation added, and the 5 has been replaced with a constant.

+
+  scoped_ptr<TLSSocket> socket(
+      new TLSSocket(ssl_socket, tcp_client_socket, FAKE_ID));
+
+  net::CompletionCallback callback;
+  EXPECT_CALL(*ssl_socket, Write(_, _, _)).Times(5).WillRepeatedly(
+      testing::DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
+  scoped_refptr<net::IOBufferWithSize> io_buffers[5];
+  int i;
+  for (i = 0; i < 5; i++) {
+    io_buffers[i] = new net::IOBufferWithSize(128 + i * 50);
+    scoped_refptr<net::IOBufferWithSize> io_buffer1(
+        new net::IOBufferWithSize(42));
+    socket->Write(io_buffers[i].get(),
+                  io_buffers[i]->size(),
+                  base::Bind(&CompleteHandler::OnComplete,
+                             base::Unretained(&handlers[i])));
+
+    EXPECT_CALL(handlers[i], OnComplete(io_buffers[i]->size())).Times(1);
+  }
+
+  for (i = 0; i < 5; i++) {
+    callback.Run(128 + i * 50);
+  }
+}
+
+}  // namespace extensions