Add request_id to HttpRequestInfo and pass it to the NetworkDelegate for events.

net/base/network_delegate.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_BASE_NETWORK_DELEGATE_H_
 #define NET_BASE_NETWORK_DELEGATE_H_
 #pragma once
 
 #include "base/threading/non_thread_safe.h"
 #include "net/base/completion_callback.h"
@@ skipping 16 matching lines @@
 
 class NetworkDelegate : public base::NonThreadSafe {
  public:
   virtual ~NetworkDelegate() {}
 
   // Notification interface called by the network stack. Note that these
   // functions mostly forward to the private virtuals. They also add some sanity
   // checking on parameters.
   bool NotifyBeforeURLRequest(URLRequest* request,
                               CompletionCallback* callback);
-  void NotifySendHttpRequest(HttpRequestHeaders* headers);
+  bool NotifyBeforeSendHeaders(uint64 request_id,

[rvargas (doing something else), 2011/03/24 18:16:03]

Given that this is part of the network interface, and it receives a net
completion callback, I suggest making these methods return a net error code
instead of bool. I've heard that to be sort of a requisite to use this type of
callback.

It would be nice to have the comment about when the callback is invoked here,
because this is the point where the caller supplies the callback and should know
what to expect.

[Matt Perry, 2011/03/24 22:10:53]

Done.
I've added a comment pointing to the virtual methods below, to stick with the
pattern established in this header already.

+                               HttpRequestHeaders* headers,
+                               CompletionCallback* callback);
   void NotifyResponseStarted(URLRequest* request);
   void NotifyReadCompleted(URLRequest* request, int bytes_read);
 
   // Returns a URLRequestJob that will be used to handle the request if
   // non-null.
   // TODO(koz): Currently this is called inside registered ProtocolFactories,
   // so that we can perform Delegate-dependent request handling from the static
   // factories, but ultimately it should be called directly from
   // URLRequestJobManager::CreateJob() as a general override mechanism.
   URLRequestJob* MaybeCreateURLRequestJob(URLRequest* request);
 
+  void NotifyURLRequestDestroyed(URLRequest* request);
+
  private:
   // This is the interface for subclasses of NetworkDelegate to implement. This
   // member functions will be called by the respective public notification
   // member function, which will perform basic sanity checking.
 
-  // Called before a request is sent.
+  // Called before a request is sent. The callback can be called at any time,
+  // but will have no effect if the request has already been cancelled or
+  // deleted.
   virtual bool OnBeforeURLRequest(URLRequest* request,
                                   CompletionCallback* callback) = 0;
 
   // Called right before the HTTP headers are sent.  Allows the delegate to
-  // read/write |headers| before they get sent out.
-  virtual void OnSendHttpRequest(HttpRequestHeaders* headers) = 0;
+  // read/write |headers| before they get sent out. The callback can be called
+  // at any time, but will have no effect if the transaction handling this
+  // request has been cancelled.
+  virtual bool OnBeforeSendHeaders(uint64 request_id,
+                                   HttpRequestHeaders* headers,
+                                   CompletionCallback* callback) = 0;
 
   // This corresponds to URLRequestDelegate::OnResponseStarted.
   virtual void OnResponseStarted(URLRequest* request) = 0;
 
   // This corresponds to URLRequestDelegate::OnReadCompleted.
   virtual void OnReadCompleted(URLRequest* request, int bytes_read) = 0;
 
   // Called before a request is sent and before a URLRequestJob is created to
   // handle the request.
   virtual URLRequestJob* OnMaybeCreateURLRequestJob(URLRequest* request) = 0;
+
+  // Called when an URLRequest is being destroyed.
+  virtual void OnURLRequestDestroyed(URLRequest* request) = 0;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_DELEGATE_H_