Adds URLRequestJob bytes read to NetLog.

net/socket/ssl_client_socket_mac.cc

 // 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.
 
 #include "net/socket/ssl_client_socket_mac.h"
 
 #include <CoreServices/CoreServices.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ skipping 1177 matching lines @@
   // There's a subtle difference here in semantics of the "would block" errors.
   // In our code, ERR_IO_PENDING means the whole operation is async, while
   // errSSLWouldBlock means that the stream isn't ending (and is often returned
   // along with partial data). So even though "would block" is returned, if we
   // have data, let's just return it. This is further complicated by the fact
   // that errSSLWouldBlock is also used to short-circuit SSLRead()'s
   // transparent renegotiation, so that we can update our state machine above,
   // which otherwise would get out of sync with the SSLContextRef's internal
   // state machine.
   if (processed > 0) {
-    LogByteTransfer(net_log_, NetLog::TYPE_SSL_SOCKET_BYTES_RECEIVED,
-                    processed, user_read_buf_->data());
+    net_log_.AddByteTransferEvent(NetLog::TYPE_SSL_SOCKET_BYTES_RECEIVED,
+                                  processed, user_read_buf_->data());
     return processed;
   }
 
   switch (status) {
     case errSSLClosedNoNotify:
       // TODO(wtc): Unless we have received the close_notify alert, we need to
       // return an error code indicating that the SSL connection ended
       // uncleanly, a potential truncation attack.  See http://crbug.com/18586.
       return OK;
 
     default:
       return NetErrorFromOSStatus(status);
   }
 }
 
 int SSLClientSocketMac::DoPayloadWrite() {
   // Too much data in flight?
   if (send_buffer_.size() > kWriteSizePauseLimit)
     return ERR_IO_PENDING;
 
   size_t processed = 0;
   OSStatus status = SSLWrite(ssl_context_,
                              user_write_buf_->data(),
                              user_write_buf_len_,
                              &processed);
 
   if (processed > 0) {
-    LogByteTransfer(net_log_, NetLog::TYPE_SSL_SOCKET_BYTES_SENT, processed,
-                    user_write_buf_->data());
+    net_log_.AddByteTransferEvent(NetLog::TYPE_SSL_SOCKET_BYTES_SENT, processed,
+                                  user_write_buf_->data());
     return processed;
   }
 
   return NetErrorFromOSStatus(status);
 }
 
 int SSLClientSocketMac::DoCompletedRenegotiation(int result) {
   // The user had a read in progress, which was interrupted by the
   // renegotiation. Return the application data that was processed after the
   // handshake completed.
@@ skipping 154 matching lines @@
   if (rv < 0 && rv != ERR_IO_PENDING) {
     us->write_io_buf_ = NULL;
     return OSStatusFromNetError(rv);
   }
 
   // always lie to our caller
   return noErr;
 }
 
 }  // namespace net