NetLogEventParameter to Callback refactoring 5.

net/http/http_network_transaction.cc

 // 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.
 
 #include "net/http/http_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 75 matching lines @@
     case ERR_BAD_SSL_CLIENT_AUTH_CERT:
     case ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED:
     case ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY:
     case ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED:
       return true;
     default:
       return false;
   }
 }
 
-class SSLVersionFallbackParams : public NetLog::EventParameters {
- public:
-  SSLVersionFallbackParams(const std::string& host_and_port,
-                           int net_error,
-                           uint16 version_before,
-                           uint16 version_after)
-      : host_and_port_(host_and_port),
-        net_error_(net_error),
-        version_before_(version_before),
-        version_after_(version_after) {
-  }
-
-  virtual Value* ToValue() const {
-    DictionaryValue* dict = new DictionaryValue();
-    dict->SetString("host_and_port", host_and_port_);
-    dict->SetInteger("net_error", net_error_);
-    dict->SetInteger("version_before", version_before_);
-    dict->SetInteger("version_after", version_after_);
-    return dict;
-  }
-
- protected:
-  virtual ~SSLVersionFallbackParams() {}
-
- private:
-  const std::string host_and_port_;
-  const int net_error_;  // Network error code that caused the fallback.
-  const uint16 version_before_;  // SSL version before the fallback.
-  const uint16 version_after_;  // SSL version after the fallback.
-};
+Value* NetLogSSLVersionFallbackCallback(const GURL* url,
+                                        int net_error,
+                                        uint16 version_before,
+                                        uint16 version_after,
+                                        NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("host_and_port", GetHostAndPort(*url));
+  dict->SetInteger("net_error", net_error);
+  dict->SetInteger("version_before", version_before);
+  dict->SetInteger("version_after", version_after);
+  return dict;
+}
 
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
 HttpNetworkTransaction::HttpNetworkTransaction(HttpNetworkSession* session)
     : pending_auth_target_(HttpAuth::AUTH_NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
           base::Bind(&HttpNetworkTransaction::OnIOComplete,
                      base::Unretained(this)))),
@@ skipping 411 matching lines @@
         break;
       case STATE_GENERATE_SERVER_AUTH_TOKEN:
         DCHECK_EQ(OK, rv);
         rv = DoGenerateServerAuthToken();
         break;
       case STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE:
         rv = DoGenerateServerAuthTokenComplete(rv);
         break;
       case STATE_BUILD_REQUEST:
         DCHECK_EQ(OK, rv);
-        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST, NULL);
+        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);
         rv = DoBuildRequest();
         break;
       case STATE_BUILD_REQUEST_COMPLETE:
         rv = DoBuildRequestComplete(rv);
         break;
       case STATE_SEND_REQUEST:
         DCHECK_EQ(OK, rv);
         rv = DoSendRequest();
         break;
       case STATE_SEND_REQUEST_COMPLETE:
         rv = DoSendRequestComplete(rv);
         net_log_.EndEventWithNetErrorCode(
             NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST, rv);
         break;
       case STATE_READ_HEADERS:
         DCHECK_EQ(OK, rv);
-        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS, NULL);
+        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);
         rv = DoReadHeaders();
         break;
       case STATE_READ_HEADERS_COMPLETE:
         rv = DoReadHeadersComplete(rv);
         net_log_.EndEventWithNetErrorCode(
             NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS, rv);
         break;
       case STATE_READ_BODY:
         DCHECK_EQ(OK, rv);
-        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_BODY, NULL);
+        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_BODY);
         rv = DoReadBody();
         break;
       case STATE_READ_BODY_COMPLETE:
         rv = DoReadBodyComplete(rv);
         net_log_.EndEventWithNetErrorCode(
             NetLog::TYPE_HTTP_TRANSACTION_READ_BODY, rv);
         break;
       case STATE_DRAIN_BODY_FOR_AUTH_RESTART:
         DCHECK_EQ(OK, rv);
         net_log_.BeginEvent(
-            NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART, NULL);
+            NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART);
         rv = DoDrainBodyForAuthRestart();
         break;
       case STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE:
         rv = DoDrainBodyForAuthRestartComplete(rv);
         net_log_.EndEventWithNetErrorCode(
             NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART, rv);
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
@@ skipping 594 matching lines @@
         // NOTE: if the SSLClientSocket class doesn't support TLS 1.1,
         // specifying TLS 1.1 in version_max will result in a TLS 1.0
         // handshake, so falling back from TLS 1.1 to TLS 1.0 will simply
         // repeat the TLS 1.0 handshake. To avoid this problem, the default
         // version_max should match the maximum protocol version supported
         // by the SSLClientSocket class.
         uint16 version_before = server_ssl_config_.version_max;
         server_ssl_config_.version_max--;
         net_log_.AddEvent(
             NetLog::TYPE_SSL_VERSION_FALLBACK,
-            make_scoped_refptr(new SSLVersionFallbackParams(
-                GetHostAndPort(request_->url), error,
-                version_before, server_ssl_config_.version_max)));
+            base::Bind(&NetLogSSLVersionFallbackCallback,
+                       &request_->url, error, version_before,
+                       server_ssl_config_.version_max));
         server_ssl_config_.version_fallback = true;
         ResetConnectionAndRequestForResend();
         error = OK;
       }
       break;
     case ERR_SSL_DECOMPRESSION_FAILURE_ALERT:
     case ERR_SSL_BAD_RECORD_MAC_ALERT:
       if (server_ssl_config_.version_max >= SSL_PROTOCOL_VERSION_TLS1 &&
           server_ssl_config_.version_min == SSL_PROTOCOL_VERSION_SSL3) {
         // This could be a server with buggy DEFLATE support. Turn off TLS,
         // DEFLATE support and retry.
         // TODO(wtc): turn off DEFLATE support only. Do not tie it to TLS.
         uint16 version_before = server_ssl_config_.version_max;
         server_ssl_config_.version_max = SSL_PROTOCOL_VERSION_SSL3;
         net_log_.AddEvent(
             NetLog::TYPE_SSL_VERSION_FALLBACK,
-            make_scoped_refptr(new SSLVersionFallbackParams(
-                GetHostAndPort(request_->url), error,
-                version_before, server_ssl_config_.version_max)));
+            base::Bind(&NetLogSSLVersionFallbackCallback,
+                       &request_->url, error, version_before,
+                       server_ssl_config_.version_max));
         server_ssl_config_.version_fallback = true;
         ResetConnectionAndRequestForResend();
         error = OK;
       }
       break;
   }
   return error;
 }
 
 // This method determines whether it is safe to resend the request after an
@@ skipping 19 matching lines @@
     case ERR_CONNECTION_ABORTED:
     // There can be a race between the socket pool checking checking whether a
     // socket is still connected, receiving the FIN, and sending/reading data
     // on a reused socket.  If we receive the FIN between the connectedness
     // check and writing/reading from the socket, we may first learn the socket
     // is disconnected when we get a ERR_SOCKET_NOT_CONNECTED.  This will most
     // likely happen when trying to retrieve its IP address.
     // See http://crbug.com/105824 for more details.
     case ERR_SOCKET_NOT_CONNECTED:
       if (ShouldResendRequest(error)) {
-        net_log_.AddEvent(
-            NetLog::TYPE_HTTP_TRANSACTION_RESTART_AFTER_ERROR,
-            make_scoped_refptr(new NetLogIntegerParameter("net_error", error)));
+        net_log_.AddEventWithNetErrorCode(
+            NetLog::TYPE_HTTP_TRANSACTION_RESTART_AFTER_ERROR, error);
         ResetConnectionAndRequestForResend();
         error = OK;
       }
       break;
     case ERR_PIPELINE_EVICTION:
       if (!session_->force_http_pipelining()) {
-        net_log_.AddEvent(
-            NetLog::TYPE_HTTP_TRANSACTION_RESTART_AFTER_ERROR,
-            make_scoped_refptr(new NetLogIntegerParameter("net_error", error)));
+        net_log_.AddEventWithNetErrorCode(
+            NetLog::TYPE_HTTP_TRANSACTION_RESTART_AFTER_ERROR, error);
         ResetConnectionAndRequestForResend();
         error = OK;
       }
       break;
     case ERR_SPDY_PING_FAILED:
     case ERR_SPDY_SERVER_REFUSED_STREAM:
-      net_log_.AddEvent(
-          NetLog::TYPE_HTTP_TRANSACTION_RESTART_AFTER_ERROR,
-          make_scoped_refptr(new NetLogIntegerParameter("net_error", error)));
+      net_log_.AddEventWithNetErrorCode(
+          NetLog::TYPE_HTTP_TRANSACTION_RESTART_AFTER_ERROR, error);
       ResetConnectionAndRequestForResend();
       error = OK;
       break;
   }
   return error;
 }
 
 void HttpNetworkTransaction::ResetStateForRestart() {
   ResetStateForAuthRestart();
   stream_.reset();
@@ skipping 128 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net