Update the FLIP session to use the FlipIOBuffer....

net/flip/flip_session.h

 // Copyright (c) 2009 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_FLIP_FLIP_SESSION_H_
 #define NET_FLIP_FLIP_SESSION_H_
 
 #include <deque>
 #include <list>
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/ref_counted.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/upload_data_stream.h"
 #include "net/flip/flip_framer.h"
+#include "net/flip/flip_io_buffer.h"
 #include "net/flip/flip_protocol.h"
 #include "net/flip/flip_session_pool.h"
 #include "net/socket/client_socket.h"
 #include "net/socket/client_socket_handle.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 class FlipStream;
 class HttpNetworkSession;
@@ skipping 48 matching lines @@
   virtual void OnDataReceived(const char* buffer, int bytes) = 0;
 
   // Called by the FlipSession when the request is finished.  This callback
   // will always be called at the end of the request and signals to the
   // delegate that the delegate can be torn down.  No further callbacks to the
   // delegate will be made after this call.
   // |status| is an error code or OK.
   virtual void OnClose(int status) = 0;
 };
 
-class PrioritizedIOBuffer {
- public:
-  PrioritizedIOBuffer() : buffer_(0), priority_(0) {}
-  PrioritizedIOBuffer(IOBufferWithSize* buffer, int priority)
-      : buffer_(buffer),
-        priority_(priority),
-        position_(++order_) {
-  }
-
-  IOBuffer* buffer() const { return buffer_; }
-
-  size_t size() const { return buffer_->size(); }
-
-  void release() { buffer_ = NULL; }
-
-  int priority() { return priority_; }
-
-  // Supports sorting.
-  bool operator<(const PrioritizedIOBuffer& other) const {
-    if (priority_ != other.priority_)
-      return priority_ > other.priority_;
-    return position_ >= other.position_;
-  }
-
- private:
-  scoped_refptr<IOBufferWithSize> buffer_;
-  int priority_;
-  int position_;
-  static int order_;  // Maintains a FIFO order for equal priorities.
-};
-
 class FlipSession : public base::RefCounted<FlipSession>,
                     public flip::FlipFramerVisitorInterface {
  public:
   // Factory for finding open sessions.
   // TODO(mbelshe): Break this out into a connection pool class?
   static FlipSession* GetFlipSession(const HostResolver::RequestInfo&,
                                      HttpNetworkSession* session);
   virtual ~FlipSession();
 
   // Get the domain for this FlipSession.
@@ skipping 112 matching lines @@
   typedef std::map<int, FlipStream*> ActiveStreamMap;
   typedef std::list<FlipStream*> ActiveStreamList;
   ActiveStreamMap active_streams_;
 
   ActiveStreamList pushed_streams_;
   // List of streams declared in X-Associated-Content headers.
   // The key is a string representing the path of the URI being pushed.
   std::map<std::string, FlipDelegate*> pending_streams_;
 
   // As we gather data to be sent, we put it into the output queue.
-  typedef std::priority_queue<PrioritizedIOBuffer> OutputQueue;
+  typedef std::priority_queue<FlipIOBuffer> OutputQueue;
   OutputQueue queue_;
 
   // TODO(mbelshe): this is ugly!!
   // The packet we are currently sending.
-  PrioritizedIOBuffer in_flight_write_;
+  FlipIOBuffer in_flight_write_;
   bool delayed_write_pending_;
   bool write_pending_;
 
   // Flip Frame state.
   flip::FlipFramer flip_framer_;
 
   // This is our weak session pool - one session per domain.
   static scoped_ptr<FlipSessionPool> session_pool_;
   static bool use_ssl_;
 };
 
 }  // namespace net
 
 #endif  // NET_FLIP_FLIP_SESSION_H_