Pepper WebSocket API: Implement new design Chrome IPC

content/renderer/pepper/pepper_websocket_host.cc

+// Copyright (c) 2012 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/renderer/pepper/pepper_websocket_host.h"
+
+#include <string>
+
+#include "content/public/renderer/renderer_ppapi_host.h"
+#include "net/base/net_util.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/ppb_websocket.h"
+#include "ppapi/host/dispatch_host_message.h"
+#include "ppapi/host/host_message_context.h"
+#include "ppapi/host/ppapi_host.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebArrayBuffer.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebSocket.h"
+
+using WebKit::WebArrayBuffer;
+using WebKit::WebDocument;
+using WebKit::WebString;
+using WebKit::WebSocket;
+using WebKit::WebURL;
+
+namespace content {
+
+PepperWebSocketHost::PepperWebSocketHost(
+    RendererPpapiHost* host,
+    PP_Instance instance,
+    PP_Resource resource)
+    : ResourceHost(host->GetPpapiHost(), instance, resource),
+      renderer_ppapi_host_(host),
+      initiating_close_(false),
+      accepting_close_(false),
+      error_was_received_(false) {
+}
+
+PepperWebSocketHost::~PepperWebSocketHost() {
+  if (websocket_.get())
+    websocket_->disconnect();
+}
+
+int32_t PepperWebSocketHost::OnResourceMessageReceived(
+    const IPC::Message& msg,
+    ppapi::host::HostMessageContext* context) {
+  IPC_BEGIN_MESSAGE_MAP(PepperWebSocketHost, msg)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_Connect,
+                                      OnHostMsgConnect)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_Close,
+                                      OnHostMsgClose)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_SendText,
+                                      OnHostMsgSendText)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_SendBinary,
+                                      OnHostMsgSendBinary)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_Fail,
+                                      OnHostMsgFail)
+  IPC_END_MESSAGE_MAP()
+  return PP_ERROR_FAILED;
+}
+
+void PepperWebSocketHost::didConnect() {
+  std::string protocol;
+  if (websocket_.get())
+    protocol = websocket_->subprotocol().utf8();
+  connect_reply_.params.set_result(PP_OK);
+  host()->SendReply(connect_reply_,
+                    PpapiPluginMsg_WebSocket_ConnectReply(
+                        std::string(),
+                        protocol));
+}
+
+void PepperWebSocketHost::didReceiveMessage(const WebKit::WebString& message) {
+  // Dispose packets after receiving an error.
+  if (error_was_received_)
+    return;
+
+  // Send an IPC to transport received data.
+  std::string string_message = message.utf8();
+  host()->SendUnsolicitedReply(pp_resource(),
+                               PpapiPluginMsg_WebSocket_ReceiveTextReply(
+                                  string_message));
+}
+
+void PepperWebSocketHost::didReceiveArrayBuffer(
+    const WebKit::WebArrayBuffer& binaryData) {
+  // Dispose packets after receiving an error.
+  if (error_was_received_)
+    return;
+
+  // Send an IPC to transport received data.
+  uint8_t* data = static_cast<uint8_t*>(binaryData.data());
+  std::vector<uint8_t> array_message(data, data + binaryData.byteLength());
+  host()->SendUnsolicitedReply(pp_resource(),
+                               PpapiPluginMsg_WebSocket_ReceiveBinaryReply(
+                                  array_message));
+}
+
+void PepperWebSocketHost::didReceiveMessageError() {
+  error_was_received_ = true;
+
+  // Send an IPC to report error.
+  host()->SendUnsolicitedReply(pp_resource(),
+                               PpapiPluginMsg_WebSocket_ErrorReply());
+}
+
+void PepperWebSocketHost::didUpdateBufferedAmount(
+    unsigned long buffered_amount) {
+  // Send an IPC to update buffered amount.
+  host()->SendUnsolicitedReply(pp_resource(),
+                               PpapiPluginMsg_WebSocket_BufferedAmountReply(
+                                  buffered_amount));
+}
+
+void PepperWebSocketHost::didStartClosingHandshake() {
+  accepting_close_ = true;
+
+  // Send an IPC to notice that server starts closing handshake.
+  host()->SendUnsolicitedReply(pp_resource(),
+                               PpapiPluginMsg_WebSocket_StateReply(
+                                  PP_WEBSOCKETREADYSTATE_CLOSING));
+}
+
+void PepperWebSocketHost::didClose(unsigned long unhandled_buffered_amount,
+                                   ClosingHandshakeCompletionStatus status,
+                                   unsigned short code,
+                                   const WebKit::WebString& reason) {
+  // Set close_was_clean_.
+  bool was_clean =
+      (initiating_close_ || accepting_close_) &&
+      !unhandled_buffered_amount &&
+      status == WebSocketClient::ClosingHandshakeComplete;
+
+  if (initiating_close_) {
+    initiating_close_ = false;
+    close_reply_.params.set_result(PP_OK);
+    host()->SendReply(close_reply_, PpapiPluginMsg_WebSocket_CloseReply(
+          unhandled_buffered_amount,
+          was_clean,
+          code,
+          reason.utf8()));
+  } else {
+    accepting_close_ = false;
+    host()->SendUnsolicitedReply(pp_resource(),
+                                 PpapiPluginMsg_WebSocket_ClosedReply(
+                                     unhandled_buffered_amount,
+                                     was_clean,
+                                     code,
+                                     reason.utf8()));
+  }
+
+  // Disconnect.
+  if (websocket_.get())
+    websocket_->disconnect();
+}
+
+int32_t PepperWebSocketHost::OnHostMsgConnect(
+    ppapi::host::HostMessageContext* context,
+    const std::string& url,
+    const std::vector<std::string>& protocols) {
+  std::string spec;
+  connect_reply_ = context->MakeReplyMessageContext();
+  int32_t result = DoConnect(url, protocols, &spec);
+  connect_reply_.params.set_result(result);
+  host()->SendReply(connect_reply_,

[brettw, 2012/10/03 20:30:24]

As with the comment below, you shouldn't need to explicitly call SendReply
unless you want to return non-default arguments or you need to return sometime
in the future (in which case you would return PP_OK_COMPLETIONPENDING) from the
message handler. 

At first I thought you should just replace this with "return DoConnect(url,
protocols, &spec);" but this misses the case where the completion happens in the
future, which I think is the normal way for DoConnect to succeed. In this case,
I think your current code is sending the reply twice.

What you should do is at the bottom of DoConnect where we know the call is being
sent to WebKit and will complete asynchronously, is to save the connect_reply_
and return PP_OK_COMPLETIONPENDING. Otherwise, we should return the error
immediately and not save connect_reply_, which will implicitly cause a reply to
be sent by the PpapiHost to this message.

[Takashi Toyoshima, 2012/10/05 07:35:01]

Done.

+                    PpapiPluginMsg_WebSocket_ConnectReply(spec,
+                                                          std::string()));
+  return result;
+}
+
+int32_t PepperWebSocketHost::OnHostMsgClose(
+    ppapi::host::HostMessageContext* context,
+    int32_t code,
+    const std::string& reason) {
+  close_reply_ = context->MakeReplyMessageContext();
+  if (!websocket_.get()) {

[brettw, 2012/10/03 20:30:24]

In this error case, I believe you can just return PP_ERROR_FAILED, which will
send the reply back, and then you'll call the message handler with the default
args in the resource. So I don't think you need the explicit SendReply.

Also, doing this will fix the bug where we forgot to return early from this
error case and will dereference the websocket_ below.

You shouldn't set close_reply_ in the error case. I'd move the first line in
this function below the websocket_ null check.

[Takashi Toyoshima, 2012/10/05 07:35:01]

Done.

+    close_reply_.params.set_result(PP_ERROR_FAILED);
+    host()->SendReply(close_reply_,
+                      PpapiPluginMsg_WebSocket_CloseReply(0,
+                                                          false,
+                                                          0,
+                                                          std::string()));
+  }
+  initiating_close_ = true;
+  WebString web_reason = WebString::fromUTF8(reason);
+  websocket_->close(code, web_reason);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperWebSocketHost::OnHostMsgSendText(
+    ppapi::host::HostMessageContext* context,
+    const std::string& message) {
+  if (websocket_.get()) {
+    WebString web_message = WebString::fromUTF8(message);
+    websocket_->sendText(web_message);
+  }
+  return PP_OK;
+}
+
+int32_t PepperWebSocketHost::OnHostMsgSendBinary(
+    ppapi::host::HostMessageContext* context,
+    const std::vector<uint8_t>& message) {
+  if (websocket_.get()) {
+    WebArrayBuffer web_message = WebArrayBuffer::create(message.size(), 1);
+    memcpy(web_message.data(), &message.front(), message.size());
+    websocket_->sendArrayBuffer(web_message);
+  }
+  return PP_OK;
+}
+
+int32_t PepperWebSocketHost::OnHostMsgFail(
+    ppapi::host::HostMessageContext* context,
+    const std::string& message) {
+  if (websocket_.get())
+    websocket_->fail(WebString::fromUTF8(message));
+  return PP_OK;
+}
+
+int32_t PepperWebSocketHost::DoConnect(
+    const std::string& url,
+    const std::vector<std::string>& protocols,
+    std::string* spec) {
+  // Validate url and convert it to WebURL.
+  GURL gurl(url);
+  *spec = gurl.spec();
+  if (!gurl.is_valid())
+    return PP_ERROR_BADARGUMENT;
+  if (!gurl.SchemeIs("ws") && !gurl.SchemeIs("wss"))
+    return PP_ERROR_BADARGUMENT;
+  if (gurl.has_ref())
+    return PP_ERROR_BADARGUMENT;
+  if (!net::IsPortAllowedByDefault(gurl.IntPort()))
+    return PP_ERROR_BADARGUMENT;
+  WebURL web_url(gurl);
+
+  // Validate protocols.
+  std::string protocol_string;
+  for (std::vector<std::string>::const_iterator vector_it = protocols.begin();
+       vector_it != protocols.end();
+       ++vector_it) {
+    // Check containing characters.
+    for (std::string::const_iterator string_it = vector_it->begin();
+        string_it != vector_it->end();
+        ++string_it) {
+      uint8_t character = *string_it;
+      // WebSocket specification says "(Subprotocol string must consist of)
+      // characters in the range U+0021 to U+007E not including separator
+      // characters as defined in [RFC2616]."
+      const uint8_t minimumProtocolCharacter = '!';  // U+0021.
+      const uint8_t maximumProtocolCharacter = '~';  // U+007E.
+      if (character < minimumProtocolCharacter ||
+          character > maximumProtocolCharacter ||
+          character == '"' || character == '(' || character == ')' ||
+          character == ',' || character == '/' ||
+          (character >= ':' && character <= '@') ||  // U+003A - U+0040
+          (character >= '[' && character <= ']') ||  // U+005B - u+005D
+          character == '{' || character == '}')
+        return PP_ERROR_BADARGUMENT;
+    }
+    // Join protocols with the comma separator.
+    if (vector_it != protocols.begin())
+      protocol_string.append(",");
+    protocol_string.append(*vector_it);
+  }
+
+  // Convert protocols to WebString.
+  WebString web_protocols = WebString::fromUTF8(protocol_string);
+
+  // Create WebKit::WebSocket object and connect.
+  WebKit::WebPluginContainer* container =
+      renderer_ppapi_host_->GetContainerForInstance(pp_instance());
+  if (!container)
+    return PP_ERROR_BADARGUMENT;
+  // TODO(toyoshim) Remove following WebDocument object copy.
+  WebDocument document = container->element().document();
+  websocket_.reset(WebSocket::create(document, this));
+  DCHECK(websocket_.get());
+  if (!websocket_.get())
+    return PP_ERROR_NOTSUPPORTED;
+
+  // Set receiving binary object type.
+  websocket_->setBinaryType(WebSocket::BinaryTypeArrayBuffer);
+
+  websocket_->connect(web_url, web_protocols);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+}  // namespace content