URLRequest::Interceptor enhancements...

net/url_request/url_request.h

 // Copyright (c) 2006-2008 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 <map>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
+#include "base/linked_ptr.h"
 #include "base/logging.h"
 #include "base/ref_counted.h"
+#include "base/scoped_ptr.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_states.h"
 #include "net/http/http_response_info.h"
 #include "net/url_request/url_request_status.h"
 
 namespace base {
 class Time;
 }  // namespace base
 
 namespace net {
@@ skipping 17 matching lines @@
 // consumer, and the instance is not required to live on the heap or be
 // allocated in any special way.  It is also valid to delete an URLRequest
 // object during the handling of a callback to its delegate.  Of course, once
 // the URLRequest is deleted, no further callbacks to its delegate will occur.
 //
 // NOTE: All usage of all instances of this class should be on the same thread.
 //
 class URLRequest {
  public:
   // Derive from this class and add your own data members to associate extra
-  // information with a URLRequest. Use user_data() and set_user_data()
+  // information with a URLRequest. Use GetUserData(key) and SetUserData()
   class UserData {
    public:
     UserData() {}
     virtual ~UserData() {}
   };
 
   // Callback function implemented by protocol handlers to create new jobs.
   // The factory may return NULL to indicate an error, which will cause other
   // factories to be queried.  If no factory handles the request, then the
   // default job will be used.
   typedef URLRequestJob* (ProtocolFactory)(URLRequest* request,
                                            const std::string& scheme);
 
   // This class handles network interception.  Use with
   // (Un)RegisterRequestInterceptor.
   class Interceptor {
   public:
     virtual ~Interceptor() {}
 
     // Called for every request made.  Should return a new job to handle the
     // request if it should be intercepted, or NULL to allow the request to
     // be handled in the normal manner.
     virtual URLRequestJob* MaybeIntercept(URLRequest* request) = 0;
+
+    // Called after having received a redirect response, but prior to the
+    // the request delegate being informed of the redirect. Can return a new
+    // job to replace the existing job if it should be intercepted, or NULL
+    // to allow the normal handling to continue. If a new job is provided,
+    // the delegate never sees the original redirect response, instead the
+    // response produced by the intercept job will be returned.
+    virtual URLRequestJob* MaybeInterceptRedirect(URLRequest* request,
+                                                  const GURL& location) {
+      return NULL;
+    }
+
+    // Called after having received a final response, but prior to the
+    // the request delegate being informed of the response. This is also
+    // called when there is no server response at all to allow interception
+    // on dns or network errors. Can return a new job to replace the existing
+    // job if it should be intercepted, or NULL to allow the normal handling to
+    // continue. If a new job is provided, the delegate never sees the original
+    // response, instead the response produced by the intercept job will be
+    // returned.
+    virtual URLRequestJob* MaybeInterceptResponse(URLRequest* request) {
+      return NULL;
+    }
   };
 
   // The delegate's methods are called from the message loop of the thread
   // on which the request's Start() method is called. See above for the
   // ordering of callbacks.
   //
   // The callbacks will be called in the following order:
   //   Start()
   //    - OnReceivedRedirect* (zero or more calls, for the number of redirects)
   //    - OnAuthRequired* (zero or more calls, for the number of
@@ skipping 65 matching lines @@
   };
 
   // Initialize an URL request.
   URLRequest(const GURL& url, Delegate* 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.
   ~URLRequest();
 
-  // The user data allows the owner to associate data with this request.
-  // This request will TAKE OWNERSHIP of the given pointer, and will delete
-  // the object if it is changed or the request is destroyed.
-  UserData* user_data() const {
-    return user_data_;
-  }
-  void set_user_data(UserData* user_data) {
-    if (user_data_)
-      delete user_data_;
-    user_data_ = user_data;
-  }
+  // The user data allows the clients to associate data with this request.
+  // Multiple user data values can be stored under different keys.
+  // This request will TAKE OWNERSHIP of the given data pointer, and will
+  // delete the object if it is changed or the request is destroyed.
+  UserData* GetUserData(void* key) const;
+  void SetUserData(void* key, UserData* data);
 
   // Registers a new protocol handler for the given scheme. If the scheme is
   // already handled, this will overwrite the given factory. To delete the
   // protocol factory, use NULL for the factory BUT this WILL NOT put back
   // any previously registered protocol factory. It will have returned
   // the previously registered factory (or NULL if none is registered) when
   // the scheme was first registered so that the caller can manually put it
   // back if desired.
   //
   // The scheme must be all-lowercase ASCII. See the ProtocolFactory
@@ skipping 262 matching lines @@
   // Allow the URLRequestJob class to control the is_pending() flag.
   void set_is_pending(bool value) { is_pending_ = value; }
 
   // Allow the URLRequestJob class to set our status too
   void set_status(const URLRequestStatus& value) { status_ = value; }
 
   // Allow the URLRequestJob to redirect this request.  Returns net::OK if
   // successful, otherwise an error code is returned.
   int Redirect(const GURL& location, int http_status_code);
 
+  // Called by URLRequestJob to allow interception when a redirect occurs.
+  void ReceivedRedirect(const GURL& location);
+
+  // Called by URLRequestJob to allow interception when the final response
+  // occurs.
+  void ResponseStarted();
+
+  // Allow an interceptor's URLRequestJob to restart this request.
+  // Should only be called if the original job has not started a resposne.
+  void Restart();
+
  private:
   friend class URLRequestJob;
 
+  void StartJob(URLRequestJob* job);
+  void RestartWithJob(URLRequestJob *job);
+
   // Detaches the job from this request in preparation for this object going
   // away or the job being replaced. The job will not call us back when it has
   // been orphaned.
   void OrphanJob();
 
   // Cancels the request and set the error and ssl info for this request to the
   // passed values.
   void DoCancel(int os_error, const net::SSLInfo& ssl_info);
 
   // Discard headers which have meaning in POST (Content-Length, Content-Type,
@@ skipping 23 matching lines @@
   URLRequestStatus status_;
 
   // The HTTP response info, lazily initialized.
   net::HttpResponseInfo response_info_;
 
   // Tells us whether the job is outstanding. This is true from the time
   // Start() is called to the time we dispatch RequestComplete and indicates
   // whether the job is active.
   bool is_pending_;
 
-  // Externally-defined data associated with this request
-  UserData* user_data_;
+  // Externally-defined data accessible by key
+  typedef std::map<void*, linked_ptr<UserData> > UserDataMap;
+  UserDataMap user_data_;
 
   // Whether to enable performance profiling on the job serving this request.
   bool enable_profiling_;
 
   // Number of times we're willing to redirect.  Used to guard against
   // infinite redirects.
   int redirect_limit_;
 
   // Contextual information used for this request (can be NULL).
   scoped_refptr<URLRequestContext> context_;
@@ skipping 28 matching lines @@
 #define URLREQUEST_COUNT_DTOR() url_request_metrics.object_count--
 
 #else  // disable leak checking in release builds...
 
 #define URLREQUEST_COUNT_CTOR()
 #define URLREQUEST_COUNT_DTOR()
 
 #endif  // #ifndef NDEBUG
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_