NetLogEventParameter to Callback refactoring 6.

net/url_request/url_request_http_job.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/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 260 matching lines @@
 
 void URLRequestHttpJob::NotifyBeforeSendHeadersCallback(int result) {
   SetUnblockedOnDelegate();
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, GetStatus().status());
 
   if (result == OK) {
     StartTransactionInternal();
   } else {
+    std::string source("delegate");

[eroman, 2012/06/13 18:48:11]

(Same comment as earlier applies here).

     request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
-        make_scoped_refptr(new NetLogStringParameter("source", "delegate")));
+                                 NetLog::StringCallback("source", &source));
     NotifyCanceled();
   }
 }
 
 void URLRequestHttpJob::StartTransactionInternal() {
   // NOTE: This method assumes that request_info_ is already setup properly.
 
   // If we already have a transaction, then we should restart the transaction
   // with auth provided by auth_credentials_.
 
@@ skipping 175 matching lines @@
   // We may have been canceled while retrieving cookies.
   if (GetStatus().is_success()) {
     StartTransaction();
   } else {
     NotifyCanceled();
   }
 }
 
 void URLRequestHttpJob::SaveCookiesAndNotifyHeadersComplete(int result) {
   if (result != net::OK) {
+    std::string source("delegate");

[eroman, 2012/06/13 18:48:11]

Ditto.

     request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
-        make_scoped_refptr(new NetLogStringParameter("source", "delegate")));
+                                 NetLog::StringCallback("source", &source));
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
     return;
   }
 
   DCHECK(transaction_.get());
 
   const HttpResponseInfo* response_info = transaction_->GetResponseInfo();
   DCHECK(response_info);
 
   response_cookies_.clear();
@@ skipping 181 matching lines @@
       // Note that |this| may not be deleted until
       // |on_headers_received_callback_| or
       // |NetworkDelegate::URLRequestDestroyed()| has been called.
       int error = context->network_delegate()->
           NotifyHeadersReceived(request_, on_headers_received_callback_,
                                 headers, &override_response_headers_);
       if (error != net::OK) {
         if (error == net::ERR_IO_PENDING) {
           awaiting_callback_ = true;
           request_->net_log().BeginEvent(
-              NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+              NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
         } else {
+          std::string source("delegate");

[eroman, 2012/06/13 18:48:11]

ditto.

           request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
-              make_scoped_refptr(
-                  new NetLogStringParameter("source", "delegate")));
+                                       NetLog::StringCallback("source",
+                                                              &source));
           NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error));
         }
         return;
       }
     }
 
     SaveCookiesAndNotifyHeadersComplete(net::OK);
   } else if (IsCertificateError(result)) {
     // We encountered an SSL certificate error.  Ask our delegate to decide
     // what we should do.
 
     TransportSecurityState::DomainState domain_state;
     const URLRequestContext* context = request_->context();
     const bool fatal =
         context->transport_security_state() &&
         context->transport_security_state()->GetDomainState(
             request_info_.url.host(),
             SSLConfigService::IsSNIAvailable(context->ssl_config_service()),
             &domain_state);
     NotifySSLCertificateError(transaction_->GetResponseInfo()->ssl_info, fatal);
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     NotifyCertificateRequested(
         transaction_->GetResponseInfo()->cert_request_info);
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
 void URLRequestHttpJob::OnHeadersReceivedCallback(int result) {
-  request_->net_log().EndEvent(
-      NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+  request_->net_log().EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
   awaiting_callback_ = false;
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, GetStatus().status());
 
   SaveCookiesAndNotifyHeadersComplete(result);
 }
 
 void URLRequestHttpJob::OnReadCompleted(int result) {
   read_in_progress_ = false;
@@ skipping 660 matching lines @@
   return override_response_headers_.get() ?
       override_response_headers_ :
       transaction_->GetResponseInfo()->headers;
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net