Do some refactoring of renderer_host....

chrome/browser/renderer_host/resource_dispatcher_host.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.
 
 // 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 fowards 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 48 matching lines @@
                    public ChildProcessInfo {
    public:
     // Return the URLRequestContext for the given request.
     // If NULL is returned, the default context for the profile is used.
     virtual URLRequestContext* GetRequestContext(
         uint32 request_id,
         const ViewHostMsg_Resource_Request& request_data) = 0;
 
    protected:
     explicit Receiver(ChildProcessInfo::ProcessType type)
-        : ChildProcessInfo(type) { }
-    virtual ~Receiver() { }
+        : ChildProcessInfo(type) {}
+    virtual ~Receiver() {}
   };
 
   // Holds the data we would like to associate with each request
   class ExtraRequestInfo : public URLRequest::UserData {
     friend class ResourceDispatcherHost;
    public:
     ExtraRequestInfo(ResourceHandler* handler,
                      ChildProcessInfo::ProcessType process_type,
                      int process_id,
                      int route_id,
@@ skipping 95 matching lines @@
     // Whether this request has started reading any bytes from the response
     // yet.  Will be true after the first (unpaused) call to Read.
     bool has_started_reading;
 
     // How many bytes have been read while this request has been paused.
     int paused_read_bytes;
   };
 
   class Observer {
    public:
-    virtual ~Observer() { }
+    virtual ~Observer() {}
     virtual void OnRequestStarted(ResourceDispatcherHost* resource_dispatcher,
                                   URLRequest* request) = 0;
     virtual void OnResponseCompleted(
         ResourceDispatcherHost* resource_dispatcher,
         URLRequest* request) = 0;
     virtual void OnReceivedRedirect(ResourceDispatcherHost* resource_dispatcher,
                                     URLRequest* request,
                                     const GURL& new_url) = 0;
   };
 
   // Uniquely identifies a URLRequest.
   struct GlobalRequestID {
     GlobalRequestID() : process_id(-1), request_id(-1) {
     }
     GlobalRequestID(int process_id, int request_id)
-        : process_id(process_id), request_id(request_id) { }
+        : process_id(process_id), request_id(request_id) {
+    }
 
     int process_id;
     int request_id;
 
     bool operator<(const GlobalRequestID& other) const {
       if (process_id == other.process_id)
         return request_id < other.request_id;
       return process_id < other.process_id;
     }
   };
@@ skipping 198 matching lines @@
   void ResumeRequest(const GlobalRequestID& request_id);
 
   // 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);
 
   // 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(URLRequest*, int* bytes_read);
 
   // Internal function to finish handling the ResponseStarted message.  Returns
   // true on success.
   bool CompleteResponseStarted(URLRequest* request);
 
   // Cancels the given request if it still exists. We ignore cancels from the
   // renderer in the event of a download. If |allow_delete| is true and no IO
   // is pending, the request is removed and deleted.
   void CancelRequest(int process_id,
                      int request_id,
@@ skipping 34 matching lines @@
 
   // Notify our observers that a request has been redirected.
   void NotifyReceivedRedirect(URLRequest* request,
                               int process_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_id,
-                              int tab_contents_id,
+                              int route_id,
                               const GURL& url,
                               ResourceType::Type resource_type,
                               ResourceHandler* handler);
 
   void UpdateLoadStates();
 
   void MaybeUpdateUploadProgress(ExtraRequestInfo *info, URLRequest *request);
 
   // Resumes or cancels (if |cancel_requests| is true) any blocked requests.
   void ProcessBlockedRequestsForRoute(int process_id,
@@ skipping 85 matching lines @@
   // Used during IPC message dispatching so that the handlers can get a pointer
   // to the source of the message.
   Receiver* receiver_;
 
   static bool g_is_http_prioritization_enabled;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_