NetLogEventParameter to Callback refactoring 6.

net/url_request/url_request.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.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 404 matching lines @@
   DCHECK(!job_);
   DCHECK_NE(ERR_IO_PENDING, error);
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
 
   if (blocked_on_delegate_)
     SetUnblockedOnDelegate();
 
   if (error != OK) {
+    std::string source("delegate");
     net_log_.AddEvent(NetLog::TYPE_CANCELLED,
-        make_scoped_refptr(new NetLogStringParameter("source", "delegate")));
+                      NetLog::StringCallback("source", &source));

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

I wander if we want to introduce a:
   NetLog::CStringCallback(const char*, const char*);

Doesn't seem like this is a common pattern so no big deal either way.

[mmenke, 2012/06/13 19:32:09]

I don't think we need it yet, though don't feel strongly about it.

     StartJob(new URLRequestErrorJob(this, error));
   } else if (!delegate_redirect_url_.is_empty()) {
     GURL new_url;
     new_url.Swap(&delegate_redirect_url_);
 
     URLRequestRedirectJob* job = new URLRequestRedirectJob(this, new_url);
     // Use status code 307 to preserve the method, so POST requests work.
     job->set_redirect_code(
         URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT);
     StartJob(job);
@@ skipping 122 matching lines @@
       URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(this,
                                                                   location);
   if (job) {
     RestartWithJob(job);
   } else if (delegate_) {
     delegate_->OnReceivedRedirect(this, location, defer_redirect);
   }
 }
 
 void URLRequest::NotifyResponseStarted() {
-  scoped_refptr<NetLog::EventParameters> params;
+  int net_error = OK;
   if (!status_.is_success())
-    params = new NetLogIntegerParameter("net_error", status_.error());
-  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB, params);
+    net_error = status_.error();
+  net_log_.EndEventWithNetErrorCode(NetLog::TYPE_URL_REQUEST_START_JOB,
+                                    net_error);
 
   URLRequestJob* job =
       URLRequestJobManager::GetInstance()->MaybeInterceptResponse(this);
   if (job) {
     RestartWithJob(job);
   } else {
     if (delegate_) {
       // In some cases (e.g. an event was canceled), we might have sent the
       // completion event and receive a NotifyResponseStarted() later.
       if (!has_notified_completion_ && status_.is_success()) {
@@ skipping 43 matching lines @@
   DCHECK(job_);
 
   job_->ContinueDespiteLastError();
 }
 
 void URLRequest::PrepareToRestart() {
   DCHECK(job_);
 
   // Close the current URL_REQUEST_START_JOB, since we will be starting a new
   // one.
-  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB, NULL);
+  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB);
 
   OrphanJob();
 
   response_info_ = HttpResponseInfo();
   response_info_.request_time = Time::Now();
   status_ = URLRequestStatus();
   is_pending_ = false;
 }
 
 void URLRequest::OrphanJob() {
   // When calling this function, please check that URLRequestHttpJob is
   // not in between calling NetworkDelegate::NotifyHeadersReceived receiving
   // the call back. This is currently guaranteed by the following strategies:
   // - OrphanJob is called on JobRestart, in this case the URLRequestJob cannot
   //   be receiving any headers at that time.
   // - OrphanJob is called in ~URLRequest, in this case
   //   NetworkDelegate::NotifyURLRequestDestroyed notifies the NetworkDelegate
   //   that the callback becomes invalid.
   job_->Kill();
   job_->DetachRequest();  // ensures that the job will not call us again
   job_ = NULL;
 }
 
 int URLRequest::Redirect(const GURL& location, int http_status_code) {
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_URL_REQUEST_REDIRECTED,
-        make_scoped_refptr(new NetLogStringParameter(
-            "location", location.possibly_invalid_spec())));
+        NetLog::StringCallback("location", &location.possibly_invalid_spec()));
   }
 
   if (context_ && context_->network_delegate())
     context_->network_delegate()->NotifyBeforeRedirect(this, location);
 
   if (redirect_limit_ <= 0) {
     DVLOG(1) << "disallowing redirect: exceeds limit";
     return ERR_TOO_MANY_REDIRECTS;
   }
 
@@ skipping 74 matching lines @@
     // Log error only on failure, not cancellation, as even successful requests
     // are "cancelled" on destruction.
     if (status_.status() == URLRequestStatus::FAILED)
       net_error = status_.error();
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
     net_log_ = BoundNetLog();
 
     if (context) {
       net_log_ = BoundNetLog::Make(context->net_log(),
                                    NetLog::SOURCE_URL_REQUEST);
-      net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE, NULL);
+      net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
     }
   }
 }
 
 int64 URLRequest::GetExpectedContentSize() const {
   int64 expected_content_size = -1;
   if (job_)
     expected_content_size = job_->expected_content_size();
 
   return expected_content_size;
@@ skipping 128 matching lines @@
     return;
 
   is_pending_ = false;
   has_notified_completion_ = true;
   if (context_ && context_->network_delegate())
     context_->network_delegate()->NotifyCompleted(this, job_ != NULL);
 }
 
 void URLRequest::SetBlockedOnDelegate() {
   blocked_on_delegate_ = true;
-  net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+  net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
 }
 
 void URLRequest::SetUnblockedOnDelegate() {
   if (!blocked_on_delegate_)
     return;
   blocked_on_delegate_ = false;
   load_state_param_.clear();
-  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
+  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
 }
 
 void URLRequest::set_stack_trace(const base::debug::StackTrace& stack_trace) {
   base::debug::StackTrace* stack_trace_copy =
       new base::debug::StackTrace(NULL, 0);
   *stack_trace_copy = stack_trace;
   stack_trace_.reset(stack_trace_copy);
 }
 
 const base::debug::StackTrace* URLRequest::stack_trace() const {
   return stack_trace_.get();
 }
 
 }  // namespace net