Add extra data to BrowserContext so that content layer and other embedders can stash data with it t…

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_
 #pragma once
 
-#include <map>
 #include <string>
 #include <vector>
 
 #include "base/debug/leak_tracker.h"
 #include "base/logging.h"
-#include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/string16.h"
+#include "base/supports_user_data.h"
 #include "base/time.h"
 #include "base/threading/non_thread_safe.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/auth.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/network_delegate.h"
 #include "net/base/request_priority.h"
@@ skipping 64 matching lines @@
 // A class  representing the asynchronous load of a data stream from an URL.
 //
 // The lifetime of an instance of this class is completely controlled by the
 // 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 NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe) {
+class NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe),
+                              public base::SupportsUserData {
  public:
   // 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);
 
   // HTTP request/response header IDs (via some preprocessor fun) for use with
   // SetRequestHeaderById and GetResponseHeaderById.
   enum {
 #define HTTP_ATOM(x) HTTP_ ## x,
 #include "net/http/http_atom_list.h"
 #undef HTTP_ATOM
   };
 
-  // Derive from this class and add your own data members to associate extra
-  // information with a URLRequest. Use GetUserData(key) and SetUserData()
-  class UserData {
-   public:
-    UserData() {}
-    virtual ~UserData() {}
-  };
-
   // This class handles network interception.  Use with
   // (Un)RegisterRequestInterceptor.
   class NET_EXPORT 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;
@@ skipping 163 matching lines @@
     // and bytes read will be -1.
     virtual void OnReadCompleted(URLRequest* request, int bytes_read) = 0;
   };
 
   // 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 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(const void* key) const;
-  void SetUserData(const void* key, UserData* data);
+  virtual ~URLRequest();
 
   // Returns true if the scheme can be handled by URLRequest. False otherwise.
   static bool IsHandledProtocol(const std::string& scheme);
 
   // Returns true if the url can be handled by URLRequest. False otherwise.
   // The function returns true for invalid urls because URLRequest knows how
   // to handle those.
   // NOTE: This will also return true for URLs that are handled by
   // ProtocolFactories that only work for requests that are scoped to a
   // Profile.
@@ skipping 296 matching lines @@
   // Called by URLRequestJob to allow interception when a redirect occurs.
   void NotifyReceivedRedirect(const GURL& location, bool* defer_redirect);
 
   // Allow an interceptor's URLRequestJob to restart this request.
   // Should only be called if the original job has not started a response.
   void Restart();
 
  private:
   friend class URLRequestJob;
 
-  typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
-
   // 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
   // declaration for its requirements.
@@ skipping 88 matching lines @@
   URLRequestStatus status_;
 
   // The HTTP response info, lazily initialized.
   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 accessible by key
-  UserDataMap user_data_;
-
   // Number of times we're willing to redirect.  Used to guard against
   // infinite redirects.
   int redirect_limit_;
 
   // Cached value for use after we've orphaned the job handling the
   // first transaction in a request involving redirects.
   uint64 final_upload_progress_;
 
   // The priority level for this request.  Objects like ClientSocketPool use
   // this to determine which URLRequest to allocate sockets to first.
@@ skipping 35 matching lines @@
   scoped_refptr<AuthChallengeInfo> auth_info_;
 
   base::TimeTicks creation_time_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_