Allow URLRequests from one context to have different NetworkDelegates.

net/url_request/url_request.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 245 matching lines @@
     // to Read() previously.
     //
     // If an error occurred, request->status() will contain the error,
     // and bytes read will be -1.
     virtual void OnReadCompleted(URLRequest* request, int bytes_read) = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
-  // TODO(tburkard): we should get rid of this constructor, and have each
-  // creator of a URLRequest specifically list the cookie store to be used.
-  // For now, this constructor will use the cookie store in |context|.
-  URLRequest(const GURL& url,
-             RequestPriority priority,
-             Delegate* delegate,
-             const URLRequestContext* context);
-
+  // URLRequests should almost always be created by calling
+  // URLRequestContext::CreateRequest.
+  //
+  // If no cookie store or network delegate are passed in, will use the ones
+  // from the URLRequestContext.

[willchan no longer on Chromium, 2014/08/05 22:36:43]

Is it possible to be explicit all the time? Or is it too much of a PITA to fix
existing tests?

In general, I prefer being strict and explicit, rather than tolerant and falling
back. But I suspect you did this to reduce burden of updating tests, which is
valid to me. If so, that's probably worth documenting here.

[mmenke, 2014/08/05 22:42:34]

Being explicit on the cookie_store would be a huge pain (Unless I lifted that
logic into URLRequestContext::CreateRequest instead).

Being explicit on the network delegate is a 1-line change, but I thought it
would be better to be consistent with the cookie store.

Long term, as we lock down the URLRequestContext, we should hoist that logic up
to the to the URLRequestContext, and eventually get rid of it...  But I think we
should save that for when we're tearing apart the URLRequestContext /
URLRequestContextStorage, and figuring out how we want to handle that at the
same time.  The URLRequestContext may no longer keep a pointer to the cookie
store at that point, anyways.

Also, it will probably be another 3 years before we get to that point, and
someone else will probably be doing the work by then.  :)

   URLRequest(const GURL& url,
              RequestPriority priority,
              Delegate* delegate,
              const URLRequestContext* context,
-             CookieStore* cookie_store);
+             CookieStore* cookie_store,
+             NetworkDelegate* network_delegate);
 
   // If destroyed after Start() has been called but while IO is pending,
   // then the request will be effectively canceled and the delegate
   // will not have any more of its methods called.
   virtual ~URLRequest();
 
   // Changes the default cookie policy from allowing all cookies to blocking all
   // cookies. Embedders that want to implement a more flexible policy should
   // change the default to blocking all cookies, and provide a NetworkDelegate
   // with the URLRequestContext that maintains the CookieStore.
@@ skipping 406 matching lines @@
   // Should only be called if the original job has not started a response.
   void Restart();
 
  private:
   friend class URLRequestJob;
 
   // Registers or unregisters a network interception class.
   static void RegisterRequestInterceptor(Interceptor* interceptor);
   static void UnregisterRequestInterceptor(Interceptor* interceptor);
 
-  // Initializes the URLRequest. Code shared between the two constructors.
-  // TODO(tburkard): This can ultimately be folded into a single constructor
-  // again.
-  void Init(const GURL& url,
-            RequestPriority priotity,
-            Delegate* delegate,
-            const URLRequestContext* context,
-            CookieStore* cookie_store);
-
   // Resumes or blocks a request paused by the NetworkDelegate::OnBeforeRequest
   // handler. If |blocked| is true, the request is blocked and an error page is
   // returned indicating so. This should only be called after Start is called
   // and OnBeforeRequest returns true (signalling that the request should be
   // paused).
   void BeforeRequestComplete(int error);
 
   void StartJob(URLRequestJob* job);
 
   // Restarting involves replacing the current job with a new one such as what
@@ skipping 157 matching lines @@
 
   // The proxy server used for this request, if any.
   HostPortPair proxy_server_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_