Add NetLog support to UDP sockets.

net/udp/udp_socket_win.h

 // Copyright (c) 2011 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_UDP_UDP_SOCKET_WIN_H_
 #define NET_UDP_UDP_SOCKET_WIN_H_
 #pragma once
 
 #include <winsock2.h>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/win/object_watcher.h"
 #include "net/base/completion_callback.h"
 #include "net/base/rand_callback.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
 #include "net/udp/datagram_socket.h"
 
 namespace net {
 
-class BoundNetLog;
-
 class UDPSocketWin : public base::NonThreadSafe {
  public:
   UDPSocketWin(DatagramSocket::BindType bind_type,
                const RandIntCallback& rand_int_cb,
                net::NetLog* net_log,
                const net::NetLog::Source& source);
   virtual ~UDPSocketWin();
 
   // Connect the socket to connect with a certain |address|.
   // Returns a net error code.
@@ skipping 87 matching lines @@
     virtual void OnObjectSignaled(HANDLE object);
 
    private:
     UDPSocketWin* const socket_;
   };
 
   void DoReadCallback(int rv);
   void DoWriteCallback(int rv);
   void DidCompleteRead();
   void DidCompleteWrite();
-  bool ProcessSuccessfulRead(int num_bytes, IPEndPoint* address);
-  void ProcessSuccessfulWrite(int num_bytes);
+
+  // Handles stats and logging. |result| is the number of bytes sent, on
+  // success, or the net error code on failure. Also, on success, if |address|
+  // is non-NULL, attempts to populate it using data from |recv_addr_storage_|.
+  // Returns final result code. This will just be |result|, unless unable to
+  // convert |recv_addr_storage_| to an IPEndPoint.
+  int LogRead(int result, const char* bytes, IPEndPoint* address) const;
+  // Handles stats and logging.  Values are the same as in LogRead, except
+  // |address| will not be modified.  Returns |result|.
+  int LogWrite(int result, const char* bytes, const IPEndPoint* address) const;
 
   // Returns the OS error code (or 0 on success).
   int CreateSocket(const IPEndPoint& address);
 
   // Same as SendTo(), except that address is passed by pointer
   // instead of by reference. It is called from Write() with |address|
   // set to NULL.
   int SendToOrWrite(IOBuffer* buf,
                     int buf_len,
                     const IPEndPoint* address,
                     OldCompletionCallback* callback);
 
+  int InternalConnect(const IPEndPoint& address);
   int InternalRecvFrom(IOBuffer* buf, int buf_len, IPEndPoint* address);
   int InternalSendTo(IOBuffer* buf, int buf_len, const IPEndPoint* address);
 
   int DoBind(const IPEndPoint& address);
   int RandomBind(const IPEndPoint& address);
 
   SOCKET socket_;
 
   // How to do source port binding, used only when UDPSocket is part of
   // UDPClientSocket, since UDPServerSocket provides Bind.
@@ skipping 18 matching lines @@
   // OVERLAPPED for pending read and write operations.
   OVERLAPPED read_overlapped_;
   OVERLAPPED write_overlapped_;
 
   // The buffer used by InternalRead() to retry Read requests
   scoped_refptr<IOBuffer> read_iobuffer_;
   struct sockaddr_storage recv_addr_storage_;
   socklen_t recv_addr_len_;
   IPEndPoint* recv_from_address_;
 
+  // Cached copy of the current address we're sending to, if any.  Used for
+  // logging.
+  scoped_ptr<IPEndPoint> send_to_address_;
+
   // The buffer used by InternalWrite() to retry Write requests
   scoped_refptr<IOBuffer> write_iobuffer_;
 
   // External callback; called when read is complete.
   OldCompletionCallback* read_callback_;
 
   // External callback; called when write is complete.
   OldCompletionCallback* write_callback_;
 
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(UDPSocketWin);
 };
 
 }  // namespace net
 
 #endif  // NET_UDP_UDP_SOCKET_WIN_H_