Make net::WebSocketChannel deletion safe and enable new IPCs

net/websockets/websocket_stream.h

 // 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.
 
 #ifndef NET_WEBSOCKETS_WEBSOCKET_STREAM_H_
 #define NET_WEBSOCKETS_WEBSOCKET_STREAM_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 101 matching lines @@
   // a frame is available, then the frame will be split, and the available data
   // will be returned immediately.
   //
   // When the socket is closed on the remote side, this method will return
   // ERR_CONNECTION_CLOSED. It will not return OK with an empty vector.
   //
   // If the connection is closed in the middle of receiving an incomplete frame,
   // ReadFrames may discard the incomplete frame. Since the renderer will
   // discard any incomplete messages when the connection is closed, this makes
   // no difference to the overall semantics.
+  //
+  // Implementations of ReadFrames() must be able to handle being deleted during
+  // the execution of callback.Run(). In practice this means that the method
+  // calling callback.Run() (and any calling methods in the same object) must
+  // return immediately without any further method calls or access to member
+  // variables. Implementors should write test(s) for this case.
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) = 0;
 
   // Writes WebSocket frame data.
   //
   // |frames| must be valid until the operation completes or Close() is called.
   //
   // This function must not be called while a previous call of WriteFrames() is
   // still pending.
   //
   // This method will only return OK if all frames were written completely.
   // Otherwise it will return an appropriate net error code.
+  //
+  // The callback implementation is permitted to delete this
+  // object. Implementations of WriteFrames() should be robust against
+  // this. This generally means returning to the event loop immediately after
+  // calling the callback.
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) = 0;
 
   // Closes the stream. All pending I/O operations (if any) are cancelled
   // at this point, so |frames| can be freed.
   virtual void Close() = 0;
 
   // The subprotocol that was negotiated for the stream. If no protocol was
   // negotiated, then the empty string is returned.
   virtual std::string GetSubProtocol() const = 0;
@@ skipping 12 matching lines @@
  protected:
   WebSocketStream();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebSocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_STREAM_H_