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

content/browser/renderer_host/websocket_host.h

 // Copyright 2013 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 CONTENT_BROWSER_RENDERER_HOST_WEBSOCKET_HOST_H_
 #define CONTENT_BROWSER_RENDERER_HOST_WEBSOCKET_HOST_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 42 matching lines @@
   // General message dispatch. WebSocketDispatcherHost::OnMessageReceived
   // delegates to this method after looking up the |routing_id|.
   virtual bool OnMessageReceived(const IPC::Message& message);
 
   int routing_id() const { return routing_id_; }
 
   bool handshake_succeeded() const { return handshake_succeeded_; }
   void OnHandshakeSucceeded() { handshake_succeeded_ = true; }
 
  private:
+  using ReceiveQuotaProvider = int64_t;
+  using ReceiveQuotaConsumer = int64_t;
+
+  // This class provides an abstraction for when there are multiple active
+  // providers of receive quota, but only one can actual consume receive quota
+  // (ie. receive messages) at any one time.
+  class ReceiveQuotaMultiplexer {
+   public:
+    ReceiveQuotaMultiplexer();
+
+    // set_channel must be called before any other methods.
+    void set_channel(net::WebSocketChannel* channel) { channel_ = channel; }
+
+    // Adds quota for ReceiveQuotaProvider |provider|. The amount is actually
+    // updated by this method. If |provider| is also the current quota consumer,
+    // returns true. May provide |channel_| with more quota.
+    bool AddQuota(ReceiveQuotaProvider* provider, int64_t quota);
+
+    // Returns the quota available from the currently active quota consumer. In
+    // other words, how many bytes of data may be sent to the consumer right
+    // now.
+    int64_t AvailableQuota() const;
+
+    // Marks some quota as consumed. To be called this after sending some data
+    // to the current consumer.
+    void ConsumedQuota(int64_t quota);
+
+    // Set the current consumer. The pointer remains owned by the caller, and
+    // must remain valid until this method is called again, or the class is
+    // destroyed.
+    void SetConsumer(ReceiveQuotaConsumer* consumer);
+
+   private:
+    // Calls channel_->SendFlowControl() if appropriate.
+    void PublishMoreQuotaIfNeeded();
+
+    net::WebSocketChannel* channel_;
+    int64_t published_quota_;
+    ReceiveQuotaConsumer* current_consumer_;
+
+    DISALLOW_COPY_AND_ASSIGN(ReceiveQuotaMultiplexer);
+  };
+
   // Handlers for each message type, dispatched by OnMessageReceived(), as
   // defined in content/common/websocket_messages.h
 
   void OnAddChannelRequest(const GURL& socket_url,
                            const std::vector<std::string>& requested_protocols,
                            const url::Origin& origin,
                            int render_frame_id);
 
   void AddChannel(const GURL& socket_url,
                   const std::vector<std::string>& requested_protocols,
@@ skipping 25 matching lines @@
 
   // SendFlowControl() is delayed when OnFlowControl() is called before
   // AddChannel() is called.
   // Zero indicates there is no pending SendFlowControl().
   int64_t pending_flow_control_quota_;
 
   // handshake_succeeded_ is set and used by WebSocketDispatcherHost
   // to manage counters for per-renderer WebSocket throttling.
   bool handshake_succeeded_;
 
+  ReceiveQuotaMultiplexer receive_quota_multiplexer_;
+
   base::WeakPtrFactory<WebSocketHost> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_WEBSOCKET_HOST_H_