[OBSOLETE][DO NOT SUBMIT][DO NOT COMMIT]] Browser-side implementation of WebSocket Blob receive.

content/common/websocket_messages.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.
 
 // Multiply-included message file, hence no include guard.
 
 // This file defines the IPCs for the browser-side implementation of
 // WebSockets.
 //
 // This IPC interface was originally desined based on the WebSocket
@@ skipping 28 matching lines @@
 #include "url/gurl.h"
 #include "url/origin.h"
 
 #undef IPC_MESSAGE_EXPORT
 #define IPC_MESSAGE_EXPORT CONTENT_EXPORT
 #define IPC_MESSAGE_START WebSocketMsgStart
 
 IPC_ENUM_TRAITS_MAX_VALUE(content::WebSocketMessageType,
                           content::WEB_SOCKET_MESSAGE_TYPE_LAST)
 
+IPC_ENUM_TRAITS_MAX_VALUE(content::WebSocketBinaryType,
+                          content::WebSocketBinaryType::LAST)
+
 IPC_STRUCT_TRAITS_BEGIN(content::WebSocketHandshakeRequest)
   IPC_STRUCT_TRAITS_MEMBER(url)
   IPC_STRUCT_TRAITS_MEMBER(headers)
   IPC_STRUCT_TRAITS_MEMBER(headers_text)
   IPC_STRUCT_TRAITS_MEMBER(request_time)
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_TRAITS_BEGIN(content::WebSocketHandshakeResponse)
   IPC_STRUCT_TRAITS_MEMBER(url)
   IPC_STRUCT_TRAITS_MEMBER(status_code)
@@ skipping 24 matching lines @@
 // quota. See the design doc at
 // https://docs.google.com/document/d/1CDiXB9pBumhFVVfmIn1CRI6v6byxyqWu2urEE9xp714/edit
 // SendFrame or SendBlob IPCs must not be sent by the renderer until the
 // BlobSendComplete message has been received from the browser. The renderer
 // should retain a reference to the Blob until either a BlobSendComplete or
 // NotifyFailure IPC is received.
 IPC_MESSAGE_ROUTED2(WebSocketHostMsg_SendBlob,
                     std::string /* uuid */,
                     uint64_t /* expected_size */)
 
+// Indicate that the type for receiving Binary messages has changed. The
+// default type is WebSocketBinaryType::BLOB. In this mode the browser will
+// build Blobs from received messages and transmit them to the renderer with a
+// WebSocketMsg_BlobReceived IPC. The type can be changed to
+// WebSocketBinaryType::ARRAY_BUFFER, in which case Binary messages will be sent
+// to the renderer with WebSocketMsg_SendFrame IPCs in the same way as for Text
+// messages. Changes to the type only take effect at the start of the next
+// Binary message, so the render process has to be prepared to deal with a
+// message of the "wrong" type.
+IPC_MESSAGE_ROUTED1(WebSocketHostMsg_BinaryTypeChanged,
+                    content::WebSocketBinaryType /* new_type */);
+
+// After taking a reference to a Blob received via a WebSocketMsg_BlobReceived
+// IPC, the renderer should send this IPC to indicate that the browser no longer
+// needs to hold a reference to the Blob. There is no need to indicate which
+// Blob; they are confirmed in strict FIFO order.
+IPC_MESSAGE_ROUTED0(WebSocketHostMsg_BlobConfirmed);
+
 // WebSocket messages sent from the browser to the renderer.
 
 // Respond to an AddChannelRequest. |selected_protocol| is the sub-protocol the
 // server selected, or empty if no sub-protocol was selected. |extensions| is
 // the list of extensions negotiated for the connection.
 IPC_MESSAGE_ROUTED2(WebSocketMsg_AddChannelResponse,
                     std::string /* selected_protocol */,
                     std::string /* extensions */)
 
 // Notify the renderer that the browser has started an opening handshake.
@@ skipping 23 matching lines @@
 // TODO(yhirano): Find the way to pass |message| directly to the inspector
 // process.
 IPC_MESSAGE_ROUTED1(WebSocketMsg_NotifyFailure,
                     std::string /* message */)
 
 // Indicates tbat the current Blob has finished sending. The renderer can
 // release its reference on the Blob, and may now use SendFrame or SendBlob to
 // send more messages.
 IPC_MESSAGE_ROUTED0(WebSocketMsg_BlobSendComplete);
 
+// Indicates that a complete binary message has been received and stored in a
+// Blob. The Blob does not count against the flow control quota supplied by the
+// render process.
+IPC_MESSAGE_ROUTED2(WebSocketMsg_BlobReceived,
+                    std::string /* uuid */,
+                    uint64_t /* size */);
+
 // WebSocket messages that can be sent in either direction.
 
 // Send a non-control frame to the channel.
 // - If the sender is the renderer, it will be sent to the remote server.
 // - If the sender is the browser, it comes from the remote server.
 //
 // - |fin| indicates that this frame is the last in the current message.
 // - |type| is the type of the message. On the first frame of a message, it
 //   must be set to either WEB_SOCKET_MESSAGE_TYPE_TEXT or
 //   WEB_SOCKET_MESSAGE_TYPE_BINARY. On subsequent frames, it must be set to
@@ skipping 40 matching lines @@
 //   a closing handshake and the renderer cannot accept any new messages on this
 //   connection.
 IPC_MESSAGE_ROUTED3(WebSocketMsg_DropChannel,
                     bool /* was_clean */,
                     unsigned short /* code */,
                     std::string /* reason */)
 
 // Notify the renderer that a closing handshake has been initiated by the
 // server, so that it can set the Javascript readyState to CLOSING.
 IPC_MESSAGE_ROUTED0(WebSocketMsg_NotifyClosing)