Prioritize which HTTP requests get a socket first by adding a priority level ...

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
 
 #ifndef CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_
 #define CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_
 
 #include <map>
+#include <string>
+#include <vector>
 
+#include "base/basictypes.h"
+#include "base/logging.h"
 #include "base/observer_list.h"
 #include "base/process.h"
 #include "base/timer.h"
 #include "chrome/browser/renderer_host/resource_handler.h"
 #include "chrome/common/child_process_info.h"
 #include "chrome/common/filter_policy.h"
 #include "chrome/common/ipc_message.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_type.h"
 
@@ skipping 25 matching lines @@
   class Receiver : public IPC::Message::Sender,
                    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:
-    Receiver(ChildProcessInfo::ProcessType type) : ChildProcessInfo(type) { }
+    explicit Receiver(ChildProcessInfo::ProcessType type)
+        : ChildProcessInfo(type) { }
     virtual ~Receiver() { }
   };
 
   // Holds the data we would like to associate with each request
   class ExtraRequestInfo : public URLRequest::UserData {
-   friend class ResourceDispatcherHost;
+    friend class ResourceDispatcherHost;
    public:
     ExtraRequestInfo(ResourceHandler* handler,
                      ChildProcessInfo::ProcessType process_type,
                      int process_id,
                      int route_id,
                      int request_id,
                      std::string frame_origin,
                      std::string main_frame_origin,
                      ResourceType::Type resource_type,
                      uint64 upload_size)
@@ skipping 87 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 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;
   };
 
@@ skipping 165 matching lines @@
 
   // Cancels any blocked request for the specified route id.
   void CancelBlockedRequestsForRoute(int process_id, int route_id);
 
   // Decrements the pending_data_count for the request and resumes
   // the request if it was paused due to too many pending data
   // messages sent.
   void DataReceivedACK(int process_id, int request_id);
 
   // Needed for the sync IPC message dispatcher macros.
-  bool Send(IPC::Message* message) { delete message; return false; }
+  bool Send(IPC::Message* message) {
+    delete message;
+    return false;
+  }
 
  private:
   FRIEND_TEST(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies);
   FRIEND_TEST(ResourceDispatcherHostTest,
               IncrementOutstandingRequestsMemoryCost);
   FRIEND_TEST(ResourceDispatcherHostTest,
               CalculateApproximateMemoryCost);
 
   class ShutdownTask;
 
@@ skipping 45 matching lines @@
   // Estimate how much heap space |request| will consume to run.
   static int CalculateApproximateMemoryCost(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, 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_id);
 
   // Notify our observers that a request has been redirected.
@@ skipping 101 matching lines @@
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_