Make net::WebSocketChannel deletion safe and enable new IPCs

content/browser/renderer_host/websocket_host.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/browser/renderer_host/websocket_host.h"
 
 #include "base/basictypes.h"
 #include "base/strings/string_util.h"
 #include "content/browser/renderer_host/websocket_dispatcher_host.h"
 #include "content/common/websocket_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/websockets/websocket_channel.h"
 #include "net/websockets/websocket_event_interface.h"
 #include "net/websockets/websocket_frame.h"  // for WebSocketFrameHeader::OpCode
 
 namespace content {
 
 namespace {
 
+typedef net::WebSocketEventInterface::ChannelState ChannelState;
+typedef WebSocketDispatcherHost::WebSocketHostState WebSocketHostState;
+
 // Convert a content::WebSocketMessageType to a
 // net::WebSocketFrameHeader::OpCode
 net::WebSocketFrameHeader::OpCode MessageTypeToOpCode(
     WebSocketMessageType type) {
   DCHECK(type == WEB_SOCKET_MESSAGE_TYPE_CONTINUATION ||
          type == WEB_SOCKET_MESSAGE_TYPE_TEXT ||
          type == WEB_SOCKET_MESSAGE_TYPE_BINARY);
   typedef net::WebSocketFrameHeader::OpCode OpCode;
   // These compile asserts verify that the same underlying values are used for
   // both types, so we can simply cast between them.
@@ skipping 11 matching lines @@
 
 WebSocketMessageType OpCodeToMessageType(
     net::WebSocketFrameHeader::OpCode opCode) {
   DCHECK(opCode == net::WebSocketFrameHeader::kOpCodeContinuation ||
          opCode == net::WebSocketFrameHeader::kOpCodeText ||
          opCode == net::WebSocketFrameHeader::kOpCodeBinary);
   // This cast is guaranteed valid by the COMPILE_ASSERT() statements above.
   return static_cast<WebSocketMessageType>(opCode);
 }
 
+ChannelState StateCast(WebSocketHostState host_state) {
+  const WebSocketHostState WEBSOCKET_HOST_ALIVE =
+      WebSocketDispatcherHost::WEBSOCKET_HOST_ALIVE;
+  const WebSocketHostState WEBSOCKET_HOST_DELETED =
+      WebSocketDispatcherHost::WEBSOCKET_HOST_DELETED;
+
+  DCHECK(host_state == WEBSOCKET_HOST_ALIVE ||
+         host_state == WEBSOCKET_HOST_DELETED);
+  // These compile asserts verify that we can get away with using static_cast<>
+  // for the conversion.
+  COMPILE_ASSERT(static_cast<ChannelState>(WEBSOCKET_HOST_ALIVE) ==
+                     net::WebSocketEventInterface::CHANNEL_ALIVE,
+                 enum_values_must_match_for_state_alive);
+  COMPILE_ASSERT(static_cast<ChannelState>(WEBSOCKET_HOST_DELETED) ==
+                     net::WebSocketEventInterface::CHANNEL_DELETED,
+                 enum_values_must_match_for_state_deleted);
+  return static_cast<ChannelState>(host_state);
+}
+
 // Implementation of net::WebSocketEventInterface. Receives events from our
 // WebSocketChannel object. Each event is translated to an IPC and sent to the
 // renderer or child process via WebSocketDispatcherHost.
 class WebSocketEventHandler : public net::WebSocketEventInterface {
  public:
   WebSocketEventHandler(WebSocketDispatcherHost* dispatcher, int routing_id);
   virtual ~WebSocketEventHandler();
 
   // net::WebSocketEventInterface implementation
 
   // TODO(ricea): Add |extensions| parameter to pass the list of enabled
   // WebSocket extensions through to the renderer to make it visible to
   // Javascript.
-  virtual void OnAddChannelResponse(
+  virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_subprotocol) OVERRIDE;
-  virtual void OnDataFrame(bool fin,
-                           WebSocketMessageType type,
-                           const std::vector<char>& data) OVERRIDE;
-  virtual void OnClosingHandshake() OVERRIDE;
-  virtual void OnFlowControl(int64 quota) OVERRIDE;
-  virtual void OnDropChannel(uint16 code,
-                             const std::string& reason) OVERRIDE;
+  virtual ChannelState OnDataFrame(bool fin,
+                                   WebSocketMessageType type,
+                                   const std::vector<char>& data) OVERRIDE;
+  virtual ChannelState OnClosingHandshake() OVERRIDE;
+  virtual ChannelState OnFlowControl(int64 quota) OVERRIDE;
+  virtual ChannelState OnDropChannel(uint16 code,
+                                     const std::string& reason) OVERRIDE;
 
  private:
   WebSocketDispatcherHost* const dispatcher_;
   const int routing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketEventHandler);
 };
 
 WebSocketEventHandler::WebSocketEventHandler(
     WebSocketDispatcherHost* dispatcher,
     int routing_id)
     : dispatcher_(dispatcher), routing_id_(routing_id) {}
 
 WebSocketEventHandler::~WebSocketEventHandler() {
   DVLOG(1) << "WebSocketEventHandler destroyed routing_id= " << routing_id_;
 }
 
-void WebSocketEventHandler::OnAddChannelResponse(
+ChannelState WebSocketEventHandler::OnAddChannelResponse(
     bool fail,
     const std::string& selected_protocol) {
-  dispatcher_->SendAddChannelResponse(
-      routing_id_, fail, selected_protocol, std::string());
-  // |this| may have been deleted here.
+  return StateCast(dispatcher_->SendAddChannelResponse(
+      routing_id_, fail, selected_protocol, std::string()));
 }
 
-void WebSocketEventHandler::OnDataFrame(bool fin,
-                                        net::WebSocketFrameHeader::OpCode type,
-                                        const std::vector<char>& data) {
-  dispatcher_->SendFrame(routing_id_, fin, OpCodeToMessageType(type), data);
-  // |this| may have been deleted here.
+ChannelState WebSocketEventHandler::OnDataFrame(
+    bool fin,
+    net::WebSocketFrameHeader::OpCode type,
+    const std::vector<char>& data) {
+  return StateCast(dispatcher_->SendFrame(
+      routing_id_, fin, OpCodeToMessageType(type), data));
 }
 
-void WebSocketEventHandler::OnClosingHandshake() {
-  dispatcher_->SendClosing(routing_id_);
-  // |this| may have been deleted here.
+ChannelState WebSocketEventHandler::OnClosingHandshake() {
+  return StateCast(dispatcher_->SendClosing(routing_id_));
 }
 
-void WebSocketEventHandler::OnFlowControl(int64 quota) {
-  dispatcher_->SendFlowControl(routing_id_, quota);
-  // |this| may have been deleted here.
+ChannelState WebSocketEventHandler::OnFlowControl(int64 quota) {
+  return StateCast(dispatcher_->SendFlowControl(routing_id_, quota));
 }
 
-void WebSocketEventHandler::OnDropChannel(uint16 code,
-                                          const std::string& reason) {
-  dispatcher_->DoDropChannel(routing_id_, code, reason);
-  // |this| has been deleted here.
+ChannelState WebSocketEventHandler::OnDropChannel(uint16 code,
+                                                  const std::string& reason) {
+  return StateCast(dispatcher_->DoDropChannel(routing_id_, code, reason));
 }
 
 }  // namespace
 
 WebSocketHost::WebSocketHost(int routing_id,
                              WebSocketDispatcherHost* dispatcher,
                              net::URLRequestContext* url_request_context) {
   DVLOG(1) << "WebSocketHost: created routing_id= " << routing_id;
   scoped_ptr<net::WebSocketEventInterface> event_interface(
       new WebSocketEventHandler(dispatcher, routing_id));
@@ skipping 48 matching lines @@
 void WebSocketHost::OnDropChannel(uint16 code, const std::string& reason) {
   DVLOG(3) << "WebSocketDispatcherHost::OnDropChannel"
            << " routing_id= " << routing_id_ << " code= " << code
            << " reason= " << reason;
 
   channel_->StartClosingHandshake(code, reason);
 }
 
 
 }  // namespace content