[GCM] Initial work to set up directory structure and introduce socket integration

net/socket/socket_test_util.h

 // Copyright (c) 2012 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <cstring>
 #include <deque>
 #include <string>
@@ skipping 173 matching lines @@
   void set_connect_data(const MockConnect& connect) { connect_ = connect; }
 
  private:
   MockConnect connect_;
   AsyncSocket* socket_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketDataProvider);
 };
 
 // The AsyncSocket is an interface used by the SocketDataProvider to
 // complete the asynchronous read operation.

[Ryan Sleevi, 2013/09/03 23:04:08]

Comment is out of date

[Nicolas Zea, 2013/09/07 01:07:52]

n/a now

 class AsyncSocket {
  public:
   // If an async IO is pending because the SocketDataProvider returned
   // ERR_IO_PENDING, then the AsyncSocket waits until this OnReadComplete
   // is called to complete the asynchronous read operation.
   // data.async is ignored, and this read is completed synchronously as
   // part of this call.
   virtual void OnReadComplete(const MockRead& data) = 0;
   virtual void OnConnectComplete(const MockConnect& data) = 0;
+  virtual void OnWriteComplete(const MockWriteResult& result) = 0;

[Ryan Sleevi, 2013/09/03 23:04:08]

For review sake, and because socket_test_util itself is a huge file, can we
split this into a separate CL?

[Ryan Sleevi, 2013/09/03 23:04:08]

So, OnReadComplete is meant to be consumed by DelayedSocketData. That is, it's
"public", but it's supposed to be an implementation detail of the whole Socket
util stuff.

I don't see you actually using the OnWriteComplete interface here - instead,
you're using it to handle ordrering/sequencing outside of this file, and that
gives me a little concern.

This is more of a design issue on the net/ OWNERs side, in that it's not clear
how to 'best'/'correctly' use these interfaces. 

[Nicolas Zea, 2013/09/07 01:07:52]

These changes have been reverted now that I don't have a custom data provider.

 };
 
 // SocketDataProvider which responds based on static tables of mock reads and
 // writes.
 class StaticSocketDataProvider : public SocketDataProvider {
  public:
   StaticSocketDataProvider();
   StaticSocketDataProvider(MockRead* reads, size_t reads_count,
                            MockWrite* writes, size_t writes_count);
   virtual ~StaticSocketDataProvider();
@@ skipping 10 matching lines @@
   size_t write_count() const { return write_count_; }
 
   bool at_read_eof() const { return read_index_ >= read_count_; }
   bool at_write_eof() const { return write_index_ >= write_count_; }
 
   virtual void CompleteRead() {}
 
   // SocketDataProvider implementation.
   virtual MockRead GetNextRead() OVERRIDE;
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  ;  virtual void Reset() OVERRIDE;
+  virtual void Reset() OVERRIDE;
 
  private:
   MockRead* reads_;
   size_t read_index_;
   size_t read_count_;
   MockWrite* writes_;
   size_t write_index_;
   size_t write_count_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSocketDataProvider);
@@ skipping 447 matching lines @@
   virtual bool IsConnectedAndIdle() const OVERRIDE;
   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
   virtual bool WasEverUsed() const OVERRIDE;
   virtual bool UsingTCPFastOpen() const OVERRIDE;
   virtual bool WasNpnNegotiated() const OVERRIDE;
   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
 
   // AsyncSocket:
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
   virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnWriteComplete(const MockWriteResult& result) OVERRIDE;
 
  private:
   int CompleteRead();
 
   AddressList addresses_;
 
   SocketDataProvider* data_;
   int read_offset_;
   MockRead read_data_;
   bool need_read_data_;
 
   // True if the peer has closed the connection.  This allows us to simulate
   // the recv(..., MSG_PEEK) call in the IsConnectedAndIdle method of the real
   // TCPClientSocket.
   bool peer_closed_connection_;
 
   // While an asynchronous IO is pending, we save our user-buffer state.
-  IOBuffer* pending_buf_;
+  scoped_refptr<IOBuffer> pending_buf_;

[Ryan Sleevi, 2013/09/03 23:04:08]

While I agree that this is the right change, in order to match the interface,
I'm curious if you ran into a bug when working on this.

[Nicolas Zea, 2013/09/07 01:07:52]

Yep, in particular when handling a timeout, as the IOBuffer is discarded in my
socket stream when the stream is closed. If the read then finishes at a later
time it'll try to write into the buffer, but because it hadn't added a reference
it's already been destroyed by then.

   int pending_buf_len_;
   CompletionCallback pending_callback_;
   bool was_used_to_convey_data_;
 };
 
 // DeterministicSocketHelper is a helper class that can be used
 // to simulate net::Socket::Read() and net::Socket::Write()
 // using deterministic |data|.
 // Note: This is provided as a common helper class because
 // of the inheritance hierarchy of DeterministicMock[UDP,TCP]ClientSocket and a
@@ skipping 70 matching lines @@
   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual const BoundNetLog& NetLog() const OVERRIDE;
 
   // DatagramClientSocket implementation.
   virtual int Connect(const IPEndPoint& address) OVERRIDE;
 
   // AsyncSocket implementation.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
   virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnWriteComplete(const MockWriteResult& result) OVERRIDE;
 
  private:
   bool connected_;
   IPEndPoint peer_address_;
   DeterministicSocketHelper helper_;
 };
 
 // Mock TCP socket to be used in conjunction with DeterministicSocketData.
 class DeterministicMockTCPClientSocket
     : public MockClientSocket,
@@ skipping 23 matching lines @@
   virtual bool IsConnected() const OVERRIDE;
   virtual bool IsConnectedAndIdle() const OVERRIDE;
   virtual bool WasEverUsed() const OVERRIDE;
   virtual bool UsingTCPFastOpen() const OVERRIDE;
   virtual bool WasNpnNegotiated() const OVERRIDE;
   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
 
   // AsyncSocket:
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
   virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnWriteComplete(const MockWriteResult& result) OVERRIDE;
 
  private:
   DeterministicSocketHelper helper_;
 };
 
 class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
@@ skipping 23 matching lines @@
   virtual NextProtoStatus GetNextProto(std::string* proto,
                                        std::string* server_protos) OVERRIDE;
   virtual bool set_was_npn_negotiated(bool negotiated) OVERRIDE;
   virtual void set_protocol_negotiated(
       NextProto protocol_negotiated) OVERRIDE;
   virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
 
   // This MockSocket does not implement the manual async IO feature.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
   virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnWriteComplete(const MockWriteResult& result) OVERRIDE;
 
   virtual bool WasChannelIDSent() const OVERRIDE;
   virtual void set_channel_id_sent(bool channel_id_sent) OVERRIDE;
   virtual ServerBoundCertService* GetServerBoundCertService() const OVERRIDE;
 
  private:
   static void ConnectCallback(MockSSLClientSocket *ssl_client_socket,
                               const CompletionCallback& callback,
                               int rv);
 
@@ skipping 25 matching lines @@
   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual const BoundNetLog& NetLog() const OVERRIDE;
 
   // DatagramClientSocket implementation.
   virtual int Connect(const IPEndPoint& address) OVERRIDE;
 
   // AsyncSocket implementation.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
   virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnWriteComplete(const MockWriteResult& result) OVERRIDE;
 
  private:
   int CompleteRead();
 
   void RunCallbackAsync(const CompletionCallback& callback, int result);
   void RunCallback(const CompletionCallback& callback, int result);
 
   bool connected_;
   SocketDataProvider* data_;
   int read_offset_;
   MockRead read_data_;
   bool need_read_data_;
 
   // Address of the "remote" peer we're connected to.
   IPEndPoint peer_addr_;
 
   // While an asynchronous IO is pending, we save our user-buffer state.
-  IOBuffer* pending_buf_;
+  scoped_refptr<IOBuffer> pending_buf_;
   int pending_buf_len_;
   CompletionCallback pending_callback_;
 
   BoundNetLog net_log_;
 
   base::WeakPtrFactory<MockUDPClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockUDPClientSocket);
 };
 
@@ skipping 235 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_