net: Remove typedef net::URLRequest URLRequest;

chrome/browser/renderer_host/resource_dispatcher_host.h

 // Copyright (c) 2010 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.
 
 // This is the browser side of the resource dispatcher, it receives requests
 // from the child process (i.e. [Renderer, Plugin, Worker]ProcessHost), and
 // dispatches them to URLRequests. It then forwards the messages from the
 // URLRequests back to the correct process for handling.
 //
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
@@ skipping 33 matching lines @@
 class WebKitThread;
 struct DownloadSaveInfo;
 struct GlobalRequestID;
 struct ViewHostMsg_Resource_Request;
 struct ViewMsg_ClosePage_Params;
 
 namespace webkit_blob {
 class DeletableFileReference;
 }
 
-class ResourceDispatcherHost : public URLRequest::Delegate {
+class ResourceDispatcherHost : public net::URLRequest::Delegate {
  public:
   // Implemented by the client of ResourceDispatcherHost to receive messages in
   // response to a resource load.  The messages are intended to be forwarded to
   // the ResourceDispatcher in the child process via an IPC channel that the
   // client manages.
   //
   // NOTE: This class unfortunately cannot be named 'Delegate' because that
   // conflicts with the name of ResourceDispatcherHost's base class.
   //
   // If the receiver is unable to send a given message (i.e., if Send returns
@@ skipping 11 matching lines @@
 
    protected:
     explicit Receiver(ChildProcessInfo::ProcessType type, int child_id);
     virtual ~Receiver();
   };
 
   class Observer {
    public:
     virtual ~Observer() {}
     virtual void OnRequestStarted(ResourceDispatcherHost* resource_dispatcher,
-                                  URLRequest* request) = 0;
+                                  net::URLRequest* request) = 0;
     virtual void OnResponseCompleted(
         ResourceDispatcherHost* resource_dispatcher,
-        URLRequest* request) = 0;
+        net::URLRequest* request) = 0;
     virtual void OnReceivedRedirect(ResourceDispatcherHost* resource_dispatcher,
-                                    URLRequest* request,
+                                    net::URLRequest* request,
                                     const GURL& new_url) = 0;
   };
 
   ResourceDispatcherHost();
   ~ResourceDispatcherHost();
 
   void Initialize();
 
   // Puts the resource dispatcher host in an inactive state (unable to begin
   // new requests).  Cancels all pending requests.
@@ skipping 93 matching lines @@
   // Called when the onunload handler for a cross-site request has finished.
   void OnClosePageACK(const ViewMsg_ClosePage_Params& params);
 
   // Force cancels any pending requests for the given process.
   void CancelRequestsForProcess(int process_unique_id);
 
   // Force cancels any pending requests for the given route id.  This method
   // acts like CancelRequestsForProcess when route_id is -1.
   void CancelRequestsForRoute(int process_unique_id, int route_id);
 
-  // URLRequest::Delegate
-  virtual void OnReceivedRedirect(URLRequest* request,
+  // net::URLRequest::Delegate
+  virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const GURL& new_url,
                                   bool* defer_redirect);
-  virtual void OnAuthRequired(URLRequest* request,
+  virtual void OnAuthRequired(net::URLRequest* request,
                               net::AuthChallengeInfo* auth_info);
   virtual void OnCertificateRequested(
-      URLRequest* request,
+      net::URLRequest* request,
       net::SSLCertRequestInfo* cert_request_info);
-  virtual void OnSSLCertificateError(URLRequest* request,
+  virtual void OnSSLCertificateError(net::URLRequest* request,
                                      int cert_error,
                                      net::X509Certificate* cert);
-  virtual void OnSetCookie(URLRequest* request,
+  virtual void OnSetCookie(net::URLRequest* request,
                            const std::string& cookie_line,
                            const net::CookieOptions& options,
                            bool blocked_by_policy);
-  virtual void OnResponseStarted(URLRequest* request);
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read);
-  void OnResponseCompleted(URLRequest* request);
+  virtual void OnResponseStarted(net::URLRequest* request);
+  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
+  void OnResponseCompleted(net::URLRequest* request);
 
   // Helper functions to get our extra data out of a request. The given request
   // must have been one we created so that it has the proper extra data pointer.
-  static ResourceDispatcherHostRequestInfo* InfoForRequest(URLRequest* request);
+  static ResourceDispatcherHostRequestInfo* InfoForRequest(
+      net::URLRequest* request);
   static const ResourceDispatcherHostRequestInfo* InfoForRequest(
-      const URLRequest* request);
+      const net::URLRequest* request);
 
   // Extracts the render view/process host's identifiers from the given request
   // and places them in the given out params (both required). If there are no
   // such IDs associated with the request (such as non-page-related requests),
   // this function will return false and both out params will be -1.
-  static bool RenderViewForRequest(const URLRequest* request,
+  static bool RenderViewForRequest(const net::URLRequest* request,
                                    int* render_process_host_id,
                                    int* render_view_host_id);
 
   // Adds an observer.  The observer will be called on the IO thread.  To
   // observe resource events on the UI thread, subscribe to the
   // NOTIFY_RESOURCE_* notifications of the notification service.
   void AddObserver(Observer* obs);
 
   // Removes an observer.
   void RemoveObserver(Observer* obs);
 
-  // Retrieves a URLRequest.  Must be called from the IO thread.
-  URLRequest* GetURLRequest(const GlobalRequestID& request_id) const;
+  // Retrieves a net::URLRequest.  Must be called from the IO thread.
+  net::URLRequest* GetURLRequest(const GlobalRequestID& request_id) const;
 
   // Notifies our observers that a request has been cancelled.
-  void NotifyResponseCompleted(URLRequest* request, int process_unique_id);
+  void NotifyResponseCompleted(net::URLRequest* request, int process_unique_id);
 
   void RemovePendingRequest(int process_unique_id, int request_id);
 
   // Causes all new requests for the route identified by
   // |process_unique_id| and |route_id| to be blocked (not being
   // started) until ResumeBlockedRequestsForRoute or
   // CancelBlockedRequestsForRoute is called.
   void BlockRequestsForRoute(int process_unique_id, int route_id);
 
   // Resumes any blocked request for the specified route id.
@@ skipping 35 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ApplyExtensionLocalizationFilterTest, GoodScheme);
   FRIEND_TEST_ALL_PREFIXES(ApplyExtensionLocalizationFilterTest,
                            GoodSchemeWrongResourceType);
 
   class ShutdownTask;
 
   friend class ShutdownTask;
 
   // Associates the given info with the given request. The info will then be
   // owned by the request.
-  void SetRequestInfo(URLRequest* request,
+  void SetRequestInfo(net::URLRequest* request,
                       ResourceDispatcherHostRequestInfo* info);
 
   // A shutdown helper that runs on the IO thread.
   void OnShutdown();
 
   // Returns true if the request is paused.
   bool PauseRequestIfNeeded(ResourceDispatcherHostRequestInfo* info);
 
   // Resumes the given request by calling OnResponseStarted or OnReadCompleted.
   void ResumeRequest(const GlobalRequestID& request_id);
 
   // Internal function to start reading for the first time.
-  void StartReading(URLRequest* request);
+  void StartReading(net::URLRequest* request);
 
   // Reads data from the response using our internal buffer as async IO.
   // Returns true if data is available immediately, false otherwise.  If the
   // return value is false, we will receive a OnReadComplete() callback later.
-  bool Read(URLRequest* request, int* bytes_read);
+  bool Read(net::URLRequest* request, int* bytes_read);
 
   // Internal function to finish an async IO which has completed.  Returns
   // true if there is more data to read (e.g. we haven't read EOF yet and
   // no errors have occurred).
-  bool CompleteRead(URLRequest*, int* bytes_read);
+  bool CompleteRead(net::URLRequest*, int* bytes_read);
 
   // Internal function to finish handling the ResponseStarted message.  Returns
   // true on success.
-  bool CompleteResponseStarted(URLRequest* request);
+  bool CompleteResponseStarted(net::URLRequest* request);
 
   // Helper function for regular and download requests.
-  void BeginRequestInternal(URLRequest* request);
+  void BeginRequestInternal(net::URLRequest* request);
 
   // Helper function that cancels |request|.
-  void CancelRequestInternal(URLRequest* request, bool from_renderer);
+  void CancelRequestInternal(net::URLRequest* request, bool from_renderer);
 
   // Helper function that inserts |request| into the resource queue.
   void InsertIntoResourceQueue(
-      URLRequest* request,
+      net::URLRequest* request,
       const ResourceDispatcherHostRequestInfo& request_info);
 
   // Updates the "cost" of outstanding requests for |process_unique_id|.
   // The "cost" approximates how many bytes are consumed by all the in-memory
-  // data structures supporting this request (URLRequest object,
+  // data structures supporting this request (net::URLRequest object,
   // HttpNetworkTransaction, etc...).
   // The value of |cost| is added to the running total, and the resulting
   // sum is returned.
   int IncrementOutstandingRequestsMemoryCost(int cost,
                                              int process_unique_id);
 
   // Estimate how much heap space |request| will consume to run.
-  static int CalculateApproximateMemoryCost(URLRequest* request);
+  static int CalculateApproximateMemoryCost(net::URLRequest* request);
 
   // The list of all requests that we have pending. This list is not really
   // optimized, and assumes that we have relatively few requests pending at once
   // since some operations require brute-force searching of the list.
   //
   // It may be enhanced in the future to provide some kind of prioritization
   // mechanism. We should also consider a hashtable or binary tree if it turns
   // out we have a lot of things here.
-  typedef std::map<GlobalRequestID, URLRequest*> PendingRequestList;
+  typedef std::map<GlobalRequestID, net::URLRequest*> PendingRequestList;
 
   // Deletes the pending request identified by the iterator passed in.
   // This function will invalidate the iterator passed in. Callers should
   // not rely on this iterator being valid on return.
   void RemovePendingRequest(const PendingRequestList::iterator& iter);
 
   // Notify our observers that we started receiving a response for a request.
-  void NotifyResponseStarted(URLRequest* request, int process_unique_id);
+  void NotifyResponseStarted(net::URLRequest* request, int process_unique_id);
 
   // Notify our observers that a request has been redirected.
-  void NotifyReceivedRedirect(URLRequest* request,
+  void NotifyReceivedRedirect(net::URLRequest* request,
                               int process_unique_id,
                               const GURL& new_url);
 
   // Tries to handle the url with an external protocol. If the request is
   // handled, the function returns true. False otherwise.
   bool HandleExternalProtocol(int request_id,
                               int process_unique_id,
                               int route_id,
                               const GURL& url,
                               ResourceType::Type resource_type,
                               ResourceHandler* handler);
 
   // Checks all pending requests and updates the load states and upload
   // progress if necessary.
   void UpdateLoadStates();
 
   // Checks the upload state and sends an update if one is necessary.
   bool MaybeUpdateUploadProgress(ResourceDispatcherHostRequestInfo *info,
-                                 URLRequest *request);
+                                 net::URLRequest *request);
 
   // Resumes or cancels (if |cancel_requests| is true) any blocked requests.
   void ProcessBlockedRequestsForRoute(int process_unique_id,
                                       int route_id,
                                       bool cancel_requests);
 
   void OnRequestResource(const IPC::Message& msg,
                          int request_id,
                          const ViewHostMsg_Resource_Request& request_data);
   void OnSyncLoad(int request_id,
@@ skipping 16 matching lines @@
       ResourceHandler* handler, int child_id, int route_id,
       ResourceType::Type resource_type);
 
   // Creates ResourceDispatcherHostRequestInfo for a browser-initiated request
   // (a download or a page save). |download| should be true if the request
   // is a file download.
   ResourceDispatcherHostRequestInfo* CreateRequestInfoForBrowserRequest(
       ResourceHandler* handler, int child_id, int route_id, bool download);
 
   // Returns true if |request| is in |pending_requests_|.
-  bool IsValidRequest(URLRequest* request);
+  bool IsValidRequest(net::URLRequest* request);
 
   // Returns true if the message passed in is a resource related message.
   static bool IsResourceDispatcherHostMessage(const IPC::Message&);
 
   // Sets replace_extension_localization_templates on all text/css requests that
   // have "chrome-extension://" scheme.
   static void ApplyExtensionLocalizationFilter(
       const GURL& url,
       const ResourceType::Type& resource_type,
       ResourceDispatcherHostRequestInfo* request_info);
@@ skipping 49 matching lines @@
 
   // List of objects observing resource dispatching.
   ObserverList<Observer> observer_list_;
 
   // For running tasks.
   ScopedRunnableMethodFactory<ResourceDispatcherHost> method_runner_;
 
   // True if the resource dispatcher host has been shut down.
   bool is_shutdown_;
 
-  typedef std::vector<URLRequest*> BlockedRequestsList;
+  typedef std::vector<net::URLRequest*> BlockedRequestsList;
   typedef std::pair<int, int> ProcessRouteIDs;
   typedef std::map<ProcessRouteIDs, BlockedRequestsList*> BlockedRequestMap;
   BlockedRequestMap blocked_requests_map_;
 
   // Maps the process_unique_ids to the approximate number of bytes
   // being used to service its resource requests. No entry implies 0 cost.
   typedef std::map<int, int> OutstandingRequestsMemoryCostMap;
   OutstandingRequestsMemoryCostMap outstanding_requests_memory_cost_map_;
 
   // |max_outstanding_requests_cost_per_process_| is the upper bound on how
   // many outstanding requests can be issued per child process host.
   // The constraint is expressed in terms of bytes (where the cost of
   // individual requests is given by CalculateApproximateMemoryCost).
   // The total number of outstanding requests is roughly:
   //   (max_outstanding_requests_cost_per_process_ /
   //       kAvgBytesPerOutstandingRequest)
   int max_outstanding_requests_cost_per_process_;
 
   // Used during IPC message dispatching so that the handlers can get a pointer
   // to the source of the message.
   Receiver* receiver_;
 
   static bool is_prefetch_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_