[ABANDONED] Use new Websocket SendBlob IPC from renderer.

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 52 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_BlobSendComplete, DidCompleteSendingBlob)
     IPC_MESSAGE_HANDLER(WebSocketMsg_SendFrame, DidReceiveData)
     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;
 }
 
@@ skipping 50 matching lines @@
   WebSocketHandleClient* client = client_;
   Disconnect();
   if (!client)
     return;
 
   WebString message_to_pass = WebString::fromUTF8(message);
   client->didFail(this, message_to_pass);
   // |this| can be deleted here.
 }
 
+void WebSocketBridge::DidCompleteSendingBlob() {
+  DVLOG(1) << "WebSocketBridge::DidCompleteSendingBlob()";
+  if (client_)
+    client_->didCompleteSendingBlob(this);
+  // |this| can be deleted here.
+}
+
 void WebSocketBridge::DidReceiveData(bool fin,
                                      WebSocketMessageType type,
                                      const std::vector<char>& data) {
   DVLOG(1) << "WebSocketBridge::DidReceiveData("
            << fin << ", "
            << type << ", "
            << "(data size = " << data.size() << "))";
   if (!client_)
     return;
 
@@ skipping 96 matching lines @@
            << fin << ", " << type_to_pass << ", "
            << "(data size = "  << size << "))";
 
   ChildThreadImpl::current()->Send(
       new WebSocketMsg_SendFrame(channel_id_,
                                  fin,
                                  type_to_pass,
                                  std::vector<char>(data, data + size)));
 }
 
+void WebSocketBridge::sendBlob(const blink::WebString& uuid,
+                               uint64_t expected_size) {
+  if (channel_id_ == kInvalidChannelId)
+    return;
+
+  DVLOG(1) << "Bridge #" << channel_id_ << " SendBlob(" << uuid.utf8() << ", "
+           << expected_size << ")";
+
+  ChildThreadImpl::current()->Send(
+      new WebSocketHostMsg_SendBlob(channel_id_, uuid.utf8(), expected_size));
+}
+
 void WebSocketBridge::flowControl(int64_t quota) {
   if (channel_id_ == kInvalidChannelId)
     return;
 
   DVLOG(1) << "Bridge #" << channel_id_ << " FlowControl(" << quota << ")";
 
   ChildThreadImpl::current()->Send(
       new WebSocketMsg_FlowControl(channel_id_, quota));
 }
 
@@ skipping 15 matching lines @@
     return;
   WebSocketDispatcher* dispatcher =
       ChildThreadImpl::current()->websocket_dispatcher();
   dispatcher->RemoveBridge(channel_id_);
 
   channel_id_ = kInvalidChannelId;
   client_ = NULL;
 }
 
 }  // namespace content