Refactor WebSocket throttling feature.

net/socket_stream/socket_stream.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.
 
 #ifndef NET_SOCKET_STREAM_SOCKET_STREAM_H_
 #define NET_SOCKET_STREAM_SOCKET_STREAM_H_
 
 #include <deque>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/linked_ptr.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
+#include "net/base/net_errors.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_auth_handler.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
 
 class AuthChallengeInfo;
 class ClientSocketFactory;
 class HostResolver;
 class HttpAuthHandlerFactory;
 class SSLConfigService;
 class SingleRequestHostResolver;
 class SocketStreamMetrics;
-class SocketStreamThrottle;
 
 // SocketStream is used to implement Web Sockets.
 // It provides plain full-duplex stream with proxy and SSL support.
 // For proxy authentication, only basic mechanisum is supported.  It will try
 // authentication identity for proxy URL first.  If server requires proxy
 // authentication, it will try authentication identity for realm that server
 // requests.
 class SocketStream : public base::RefCountedThreadSafe<SocketStream> {
  public:
   // Derive from this class and add your own data members to associate extra
   // information with a SocketStream.  Use GetUserData(key) and
   // SetUserData(key, data).
   class UserData {
    public:
     UserData() {}
     virtual ~UserData() {}
   };
 
   class Delegate {
    public:
     virtual ~Delegate() {}
 
+    virtual int OnStartOpenConnection(SocketStream* socket,
+                                      CompletionCallback* callback) {
+      return OK;
+    }
+
     // Called when socket stream has been connected.  The socket stream accepts
     // at most |max_pending_send_allowed| so that a client of the socket stream
     // should keep track of how much it has pending and shouldn't go over
     // |max_pending_send_allowed| bytes.
     virtual void OnConnected(SocketStream* socket,
                              int max_pending_send_allowed) = 0;
 
     // Called when |amount_sent| bytes of data are sent.
     virtual void OnSentData(SocketStream* socket,
                             int amount_sent) = 0;
@@ skipping 236 matching lines @@
   // |max_pending_send_allowed_|.
   // |write_buf_| holds requested data and |current_write_buf_| is used
   // for Write operation, that is, |current_write_buf_| is
   // |write_buf_| + |write_buf_offset_|.
   scoped_refptr<IOBuffer> write_buf_;
   scoped_refptr<DrainableIOBuffer> current_write_buf_;
   int write_buf_offset_;
   int write_buf_size_;
   PendingDataQueue pending_write_bufs_;
 
-  SocketStreamThrottle* throttle_;
-
   scoped_ptr<SocketStreamMetrics> metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_STREAM_SOCKET_STREAM_H_