[ABANDONED] WebSocket Blob receive in the browser process: renderer changes

content/child/websocket_bridge.cc

 // 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.
 
 #include "content/child/websocket_bridge.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 23 matching lines @@
 using blink::WebString;
 using blink::WebURL;
 using blink::WebVector;
 
 namespace content {
 
 namespace {
 
 const unsigned short kAbnormalShutdownOpCode = 1006;
 
+WebSocketBinaryType BlinkBinaryTypeToContentWebSocketBinaryType(
+    WebSocketHandle::BinaryType binary_type) {
+  static_assert(
+      static_cast<WebSocketBinaryType>(WebSocketHandle::BinaryTypeBlob) ==
+          WebSocketBinaryType::BLOB,
+      "enum types must match");
+  static_assert(static_cast<WebSocketBinaryType>(
+                    WebSocketHandle::BinaryTypeArrayBuffer) ==
+                    WebSocketBinaryType::ARRAY_BUFFER,
+                "enum types must match");
+  DCHECK(binary_type == WebSocketHandle::BinaryTypeBlob ||
+         binary_type == WebSocketHandle::BinaryTypeArrayBuffer);
+  return static_cast<WebSocketBinaryType>(binary_type);
+}
+
 }  // namespace
 
 WebSocketBridge::WebSocketBridge()
     : channel_id_(kInvalidChannelId),
       render_frame_id_(MSG_ROUTING_NONE),
       client_(NULL) {}
 
 WebSocketBridge::~WebSocketBridge() {
   if (channel_id_ != kInvalidChannelId) {
     // The connection is abruptly disconnected by the renderer without
@@ skipping 10 matching lines @@
 bool WebSocketBridge::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebSocketBridge, msg)
     IPC_MESSAGE_HANDLER(WebSocketMsg_AddChannelResponse, DidConnect)
     IPC_MESSAGE_HANDLER(WebSocketMsg_NotifyStartOpeningHandshake,
                         DidStartOpeningHandshake)
     IPC_MESSAGE_HANDLER(WebSocketMsg_NotifyFinishOpeningHandshake,
                         DidFinishOpeningHandshake)
     IPC_MESSAGE_HANDLER(WebSocketMsg_NotifyFailure, DidFail)
     IPC_MESSAGE_HANDLER(WebSocketMsg_SendFrame, DidReceiveData)
+    IPC_MESSAGE_HANDLER(WebSocketMsg_BlobReceived, DidReceiveBlob)
     IPC_MESSAGE_HANDLER(WebSocketMsg_FlowControl, DidReceiveFlowControl)
     IPC_MESSAGE_HANDLER(WebSocketMsg_DropChannel, DidClose)
     IPC_MESSAGE_HANDLER(WebSocketMsg_NotifyClosing,
                         DidStartClosingHandshake)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WebSocketBridge::DidConnect(const std::string& selected_protocol,
@@ skipping 77 matching lines @@
       break;
     case WEB_SOCKET_MESSAGE_TYPE_BINARY:
       type_to_pass = WebSocketHandle::MessageTypeBinary;
       break;
   }
   const char* data_to_pass = data.empty() ? NULL : &data[0];
   client_->didReceiveData(this, fin, type_to_pass, data_to_pass, data.size());
   // |this| can be deleted here.
 }
 
+void WebSocketBridge::DidReceiveBlob(const std::string& uuid, uint64_t size) {
+  DVLOG(1) << "WebSocketBridge::DidReceiveBlob(" << uuid << "," << size << ")";
+
+  client_->didReceiveBlob(this, WebString::fromLatin1(uuid), size);
+}
+
 void WebSocketBridge::DidReceiveFlowControl(int64_t quota) {
   DVLOG(1) << "WebSocketBridge::DidReceiveFlowControl(" << quota << ")";
   if (!client_)
     return;
 
   client_->didReceiveFlowControl(this, quota);
   // |this| can be deleted here.
 }
 
 void WebSocketBridge::DidClose(bool was_clean,
@@ skipping 91 matching lines @@
     return;
 
   std::string reason_to_pass = reason.utf8();
   DVLOG(1) << "Bridge #" << channel_id_ << " Close("
            << code << ", " << reason_to_pass << ")";
   // This method is for closing handshake and hence |was_clean| shall be true.
   ChildThreadImpl::current()->Send(
       new WebSocketMsg_DropChannel(channel_id_, true, code, reason_to_pass));
 }
 
+void WebSocketBridge::changeBinaryType(BinaryType new_binary_type) {
+  if (channel_id_ == kInvalidChannelId)
+    return;
+
+  DVLOG(1) << "Bridge #" << channel_id_ << " ChangeBinaryType("
+           << new_binary_type << ")";
+  ChildThreadImpl::current()->Send(new WebSocketHostMsg_BinaryTypeChanged(
+      channel_id_,
+      BlinkBinaryTypeToContentWebSocketBinaryType(new_binary_type)));
+}
+
+void WebSocketBridge::confirmBlob() {
+  if (channel_id_ == kInvalidChannelId)
+    return;
+
+  DVLOG(1) << "Bridge #" << channel_id_ << " ConfirmBlob()";
+  ChildThreadImpl::current()->Send(
+      new WebSocketHostMsg_BlobConfirmed(channel_id_));
+}
+
 void WebSocketBridge::Disconnect() {
   if (channel_id_ == kInvalidChannelId)
     return;
   WebSocketDispatcher* dispatcher =
       ChildThreadImpl::current()->websocket_dispatcher();
   dispatcher->RemoveBridge(channel_id_);
 
   channel_id_ = kInvalidChannelId;
   client_ = NULL;
 }
 
 }  // namespace content