[OBSOLETE] Browser-side implementation of WebSocket Blob receive.

content/browser/renderer_host/websocket_host.cc

Index: content/browser/renderer_host/websocket_host.cc
diff --git a/content/browser/renderer_host/websocket_host.cc b/content/browser/renderer_host/websocket_host.cc
index 5551e9643bf2de32a906f1558bdfdcd88d5ab1bb..a349e35a138e4e5c914bc07d36528ce4db64ad9e 100644
--- a/content/browser/renderer_host/websocket_host.cc
+++ b/content/browser/renderer_host/websocket_host.cc
@@ -153,8 +153,7 @@ WebSocketEventHandler::WebSocketEventHandler(
     int render_frame_id)
     : dispatcher_(dispatcher),
       routing_id_(routing_id),
-      render_frame_id_(render_frame_id) {
-}
+      render_frame_id_(render_frame_id) {}
 
 WebSocketEventHandler::~WebSocketEventHandler() {
   DVLOG(1) << "WebSocketEventHandler destroyed routing_id=" << routing_id_;
@@ -164,8 +163,8 @@ ChannelState WebSocketEventHandler::OnAddChannelResponse(
     const std::string& selected_protocol,
     const std::string& extensions) {
   DVLOG(3) << "WebSocketEventHandler::OnAddChannelResponse"
-           << " routing_id=" << routing_id_
-           << " selected_protocol=\"" << selected_protocol << "\""
+           << " routing_id=" << routing_id_ << " selected_protocol=\""
+           << selected_protocol << "\""
            << " extensions=\"" << extensions << "\"";
 
   return StateCast(dispatcher_->SendAddChannelResponse(
@@ -180,8 +179,8 @@ ChannelState WebSocketEventHandler::OnDataFrame(
            << " routing_id=" << routing_id_ << " fin=" << fin
            << " type=" << type << " data is " << data.size() << " bytes";
 
-  return StateCast(dispatcher_->SendFrame(
-      routing_id_, fin, OpCodeToMessageType(type), data));
+  return StateCast(dispatcher_->SendFrame(routing_id_, fin,
+                                          OpCodeToMessageType(type), data));
 }
 
 ChannelState WebSocketEventHandler::OnClosingHandshake() {
@@ -211,8 +210,7 @@ ChannelState WebSocketEventHandler::OnDropChannel(bool was_clean,
 
 ChannelState WebSocketEventHandler::OnFailChannel(const std::string& message) {
   DVLOG(3) << "WebSocketEventHandler::OnFailChannel"
-           << " routing_id=" << routing_id_
-           << " message=\"" << message << "\"";
+           << " routing_id=" << routing_id_ << " message=\"" << message << "\"";
 
   return StateCast(dispatcher_->NotifyFailure(routing_id_, message));
 }
@@ -237,8 +235,8 @@ ChannelState WebSocketEventHandler::OnStartOpeningHandshake(
       request->headers.ToString();
   request_to_pass.request_time = request->request_time;
 
-  return StateCast(dispatcher_->NotifyStartOpeningHandshake(routing_id_,
-                                                            request_to_pass));
+  return StateCast(
+      dispatcher_->NotifyStartOpeningHandshake(routing_id_, request_to_pass));
 }
 
 ChannelState WebSocketEventHandler::OnFinishOpeningHandshake(
@@ -263,8 +261,8 @@ ChannelState WebSocketEventHandler::OnFinishOpeningHandshake(
           response->headers->raw_headers());
   response_to_pass.response_time = response->response_time;
 
-  return StateCast(dispatcher_->NotifyFinishOpeningHandshake(routing_id_,
-                                                             response_to_pass));
+  return StateCast(
+      dispatcher_->NotifyFinishOpeningHandshake(routing_id_, response_to_pass));
 }
 
 ChannelState WebSocketEventHandler::OnSSLCertificateError(
@@ -281,7 +279,7 @@ ChannelState WebSocketEventHandler::OnSSLCertificateError(
       ssl_error_handler_delegate_->GetWeakPtr(), url,
       dispatcher_->render_process_id(), render_frame_id_, ssl_info, fatal);
   // The above method is always asynchronous.
-  return WebSocketEventInterface::CHANNEL_ALIVE;
+    return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 WebSocketEventHandler::SSLErrorHandlerDelegate::SSLErrorHandlerDelegate(
@@ -312,6 +310,56 @@ void WebSocketEventHandler::SSLErrorHandlerDelegate::ContinueSSLRequest() {
 
 }  // namespace
 
+WebSocketHost::ReceiveQuotaMultiplexer::ReceiveQuotaMultiplexer()
+    : channel_(nullptr), published_quota_(0), current_consumer_(nullptr) {}
+
+// Quota can be added to any consumer at any time.
+bool WebSocketHost::ReceiveQuotaMultiplexer::AddQuota(
+    ReceiveQuotaProvider* provider,
+    int64_t quota) {
+  DCHECK(channel_);
+  DCHECK_GE(quota, 0);
+  *provider += quota;
+  if (provider == current_consumer_) {
+    PublishMoreQuotaIfNeeded();
+    return true;
+  }
+  return false;
+}
+
+// Quota can only be used from the current consumer.
+int64_t WebSocketHost::ReceiveQuotaMultiplexer::AvailableQuota() const {
+  DCHECK(current_consumer_);
+  return *current_consumer_;
+}
+
+// Quota is only consumed by the current consumer.
+void WebSocketHost::ReceiveQuotaMultiplexer::ConsumedQuota(int64_t quota) {
+  DCHECK_GE(quota, 0);
+  DCHECK_GE(*current_consumer_, quota);
+  DCHECK_GE(published_quota_, *current_consumer_);
+  *current_consumer_ -= quota;
+  published_quota_ -= quota;
+}
+
+// Changing the current consumer may result in more quota being published.
+void WebSocketHost::ReceiveQuotaMultiplexer::SetConsumer(
+    ReceiveQuotaConsumer* consumer) {
+  DCHECK(channel_);
+  DCHECK(consumer);
+  current_consumer_ = consumer;
+  PublishMoreQuotaIfNeeded();
+}
+
+void WebSocketHost::ReceiveQuotaMultiplexer::PublishMoreQuotaIfNeeded() {
+  DCHECK(channel_);
+  DCHECK(current_consumer_);
+  if (*current_consumer_ > published_quota_) {
+    channel_->SendFlowControl(published_quota_ - *current_consumer_);
+    published_quota_ = *current_consumer_;
+  }
+}
+
 WebSocketHost::WebSocketHost(int routing_id,
                              WebSocketDispatcherHost* dispatcher,
                              net::URLRequestContext* url_request_context,