Make net::WebSocketChannel deletion safe and enable new IPCs

net/websockets/websocket_channel_test.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 "net/websockets/websocket_channel.h"
 
 #include <string.h>
 
 #include <iostream>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/safe_numerics.h"
 #include "base/strings/string_piece.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context.h"
 #include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_event_interface.h"
 #include "net/websockets/websocket_mux.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 49 matching lines @@
 }
 
 std::ostream& operator<<(std::ostream& os,
                          const ScopedVector<WebSocketFrame>* vector) {
   return os << '&' << *vector;
 }
 
 namespace {
 
 using ::testing::AnyNumber;
+using ::testing::DefaultValue;
 using ::testing::InSequence;
 using ::testing::MockFunction;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::_;
 
 // A selection of characters that have traditionally been mangled in some
 // environment or other, for testing 8-bit cleanliness.
 const char kBinaryBlob[] = {'\n',   '\r',    // BACKWARDS CRNL
@@ skipping 11 matching lines @@
 
 // The amount of quota a new connection gets by default.
 // TODO(ricea): If kDefaultSendQuotaHighWaterMark changes, then this value will
 // need to be updated.
 const size_t kDefaultInitialQuota = 1 << 17;
 // The amount of bytes we need to send after the initial connection to trigger a
 // quota refresh. TODO(ricea): Change this if kDefaultSendQuotaHighWaterMark or
 // kDefaultSendQuotaLowWaterMark change.
 const size_t kDefaultQuotaRefreshTrigger = (1 << 16) + 1;
 
+typedef WebSocketEventInterface::ChannelState ChannelState;
+const ChannelState CHANNEL_ALIVE = WebSocketEventInterface::CHANNEL_ALIVE;
+const ChannelState CHANNEL_DELETED = WebSocketEventInterface::CHANNEL_DELETED;
+
+// This typedef mainly exists to avoid having to repeat the "NOLINT" incantation
+// all over the place.
+typedef MockFunction<void(int)> Checkpoint;  // NOLINT
+
 // This mock is for testing expectations about how the EventInterface is used.
 class MockWebSocketEventInterface : public WebSocketEventInterface {
  public:
-  MOCK_METHOD2(OnAddChannelResponse, void(bool, const std::string&));
+  MOCK_METHOD2(OnAddChannelResponse,
+               ChannelState(bool, const std::string&));  // NOLINT
   MOCK_METHOD3(OnDataFrame,
-               void(bool, WebSocketMessageType, const std::vector<char>&));
-  MOCK_METHOD1(OnFlowControl, void(int64));
-  MOCK_METHOD0(OnClosingHandshake, void(void));
-  MOCK_METHOD2(OnDropChannel, void(uint16, const std::string&));
+               ChannelState(bool,
+                            WebSocketMessageType,
+                            const std::vector<char>&));  // NOLINT
+  MOCK_METHOD1(OnFlowControl, ChannelState(int64));      // NOLINT
+  MOCK_METHOD0(OnClosingHandshake, ChannelState(void));  // NOLINT
+  MOCK_METHOD2(OnDropChannel,
+               ChannelState(uint16, const std::string&));  // NOLINT
 };
 
 // This fake EventInterface is for tests which need a WebSocketEventInterface
 // implementation but are not verifying how it is used.
 class FakeWebSocketEventInterface : public WebSocketEventInterface {
-  virtual void OnAddChannelResponse(
+  virtual ChannelState OnAddChannelResponse(
       bool fail,
-      const std::string& selected_protocol) OVERRIDE {}
-  virtual void OnDataFrame(bool fin,
-                           WebSocketMessageType type,
-                           const std::vector<char>& data) OVERRIDE {}
-  virtual void OnFlowControl(int64 quota) OVERRIDE {}
-  virtual void OnClosingHandshake() OVERRIDE {}
-  virtual void OnDropChannel(uint16 code, const std::string& reason) OVERRIDE {}
+      const std::string& selected_protocol) OVERRIDE {
+    return fail ? CHANNEL_DELETED : CHANNEL_ALIVE;
+  }
+  virtual ChannelState OnDataFrame(bool fin,
+                                   WebSocketMessageType type,
+                                   const std::vector<char>& data) OVERRIDE {
+    return CHANNEL_ALIVE;
+  }
+  virtual ChannelState OnFlowControl(int64 quota) OVERRIDE {
+    return CHANNEL_ALIVE;
+  }
+  virtual ChannelState OnClosingHandshake() OVERRIDE { return CHANNEL_ALIVE; }
+  virtual ChannelState OnDropChannel(uint16 code,
+                                     const std::string& reason) OVERRIDE {
+    return CHANNEL_DELETED;
+  }
 };
 
 // This fake WebSocketStream is for tests that require a WebSocketStream but are
 // not testing the way it is used. It has minimal functionality to return
 // the |protocol| and |extensions| that it was constructed with.
 class FakeWebSocketStream : public WebSocketStream {
  public:
   // Constructs with empty protocol and extensions.
   FakeWebSocketStream() {}
 
@@ skipping 390 matching lines @@
   CompletionCallback read_callback_;
   // Owned by the caller of ReadFrames().
   ScopedVector<WebSocketFrame>* read_frames_;
   // True if we should close the connection.
   bool done_;
 };
 
 // A FakeWebSocketStream where writes trigger a connection reset.
 // This differs from UnWriteableFakeWebSocketStream in that it is asynchronous
 // and triggers ReadFrames to return a reset as well. Tests using this need to
-// run the message loop.
+// run the message loop. There are two tricky parts here:
+// 1. Calling the write callback may call Close(), after which the read callback
+//    should not be called.
+// 2. Calling either callback may delete the stream altogether.
 class ResetOnWriteFakeWebSocketStream : public FakeWebSocketStream {
  public:
+  ResetOnWriteFakeWebSocketStream() : closed_(false), weak_ptr_factory_(this) {}
+
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) OVERRIDE {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, ERR_CONNECTION_RESET));
+        FROM_HERE,
+        base::Bind(&ResetOnWriteFakeWebSocketStream::CallCallbackUnlessClosed,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   callback,
+                   ERR_CONNECTION_RESET));
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(read_callback_, ERR_CONNECTION_RESET));
+        FROM_HERE,
+        base::Bind(&ResetOnWriteFakeWebSocketStream::CallCallbackUnlessClosed,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   read_callback_,
+                   ERR_CONNECTION_RESET));
     return ERR_IO_PENDING;
   }
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) OVERRIDE {
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
 
+  virtual void Close() OVERRIDE { closed_ = true; }
+
  private:
+  void CallCallbackUnlessClosed(const CompletionCallback& callback, int value) {
+    if (!closed_)
+      callback.Run(value);
+  }
+
   CompletionCallback read_callback_;
+  bool closed_;
+  // An IO error can result in the socket being deleted, so we use weak pointers
+  // to ensure correct behaviour in that case.
+  base::WeakPtrFactory<ResetOnWriteFakeWebSocketStream> weak_ptr_factory_;
 };
 
 // This mock is for verifying that WebSocket protocol semantics are obeyed (to
 // the extent that they are implemented in WebSocketCommon).
 class MockWebSocketStream : public WebSocketStream {
  public:
   MOCK_METHOD2(ReadFrames,
                int(ScopedVector<WebSocketFrame>* frames,
                    const CompletionCallback& callback));
   MOCK_METHOD2(WriteFrames,
@@ skipping 104 matching lines @@
   };
   ConnectData connect_data_;
 
   // The channel we are testing. Not initialised until SetChannel() is called.
   scoped_ptr<WebSocketChannel> channel_;
 
   // A mock or fake stream for tests that need one.
   scoped_ptr<WebSocketStream> stream_;
 };
 
+// enum of WebSocketEventInterface calls. These are intended to be or'd together
+// in order to instruct WebSocketChannelDeletingTest when it should fail.
+enum EventInterfaceCall {
+  EVENT_ON_ADD_CHANNEL_RESPONSE = 0x1,
+  EVENT_ON_DATA_FRAME = 0x2,
+  EVENT_ON_FLOW_CONTROL = 0x4,
+  EVENT_ON_CLOSING_HANDSHAKE = 0x8,
+  EVENT_ON_DROP_CHANNEL = 0x10,
+};
+
 class WebSocketChannelDeletingTest : public WebSocketChannelTest {
  public:
-  void ResetChannel() { channel_.reset(); }
+  ChannelState DeleteIfDeleting(EventInterfaceCall call) {
+    if (deleting_ & call) {
+      channel_.reset();
+      return CHANNEL_DELETED;
+    } else {
+      return CHANNEL_ALIVE;
+    }
+  }
 
  protected:
+  WebSocketChannelDeletingTest()
+      : deleting_(EVENT_ON_ADD_CHANNEL_RESPONSE | EVENT_ON_DATA_FRAME |
+                  EVENT_ON_FLOW_CONTROL |
+                  EVENT_ON_CLOSING_HANDSHAKE |
+                  EVENT_ON_DROP_CHANNEL) {}
   // Create a ChannelDeletingFakeWebSocketEventInterface. Defined out-of-line to
   // avoid circular dependency.
   virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() OVERRIDE;
+
+  // Tests can set deleting_ to a bitmap of EventInterfaceCall members that they
+  // want to cause Channel deletion. The default is for all calls to cause
+  // deletion.
+  int deleting_;
 };
 
 // A FakeWebSocketEventInterface that deletes the WebSocketChannel on failure to
 // connect.
 class ChannelDeletingFakeWebSocketEventInterface
     : public FakeWebSocketEventInterface {
  public:
   ChannelDeletingFakeWebSocketEventInterface(
       WebSocketChannelDeletingTest* fixture)
       : fixture_(fixture) {}
 
-  virtual void OnAddChannelResponse(
+  virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_protocol) OVERRIDE {
-    if (fail) {
-      fixture_->ResetChannel();
-    }
+    return fixture_->DeleteIfDeleting(EVENT_ON_ADD_CHANNEL_RESPONSE);
+  }
+
+  virtual ChannelState OnDataFrame(bool fin,
+                                   WebSocketMessageType type,
+                                   const std::vector<char>& data) OVERRIDE {
+    return fixture_->DeleteIfDeleting(EVENT_ON_DATA_FRAME);
+  }
+
+  virtual ChannelState OnFlowControl(int64 quota) OVERRIDE {
+    return fixture_->DeleteIfDeleting(EVENT_ON_FLOW_CONTROL);
+  }
+
+  virtual ChannelState OnClosingHandshake() OVERRIDE {
+    return fixture_->DeleteIfDeleting(EVENT_ON_CLOSING_HANDSHAKE);
+  }
+
+  virtual ChannelState OnDropChannel(uint16 code,
+                                     const std::string& reason) OVERRIDE {
+    return fixture_->DeleteIfDeleting(EVENT_ON_DROP_CHANNEL);
   }
 
  private:
   // A pointer to the test fixture. Owned by the test harness; this object will
   // be deleted before it is.
   WebSocketChannelDeletingTest* fixture_;
 };
 
 scoped_ptr<WebSocketEventInterface>
 WebSocketChannelDeletingTest::CreateEventInterface() {
   return scoped_ptr<WebSocketEventInterface>(
       new ChannelDeletingFakeWebSocketEventInterface(this));
 }
 
 // Base class for tests which verify that EventInterface methods are called
 // appropriately.
 class WebSocketChannelEventInterfaceTest : public WebSocketChannelTest {
  protected:
   WebSocketChannelEventInterfaceTest()
-      : event_interface_(new StrictMock<MockWebSocketEventInterface>) {}
+      : event_interface_(new StrictMock<MockWebSocketEventInterface>) {
+    DefaultValue<ChannelState>::Set(CHANNEL_ALIVE);
+    ON_CALL(*event_interface_, OnAddChannelResponse(true, _))
+        .WillByDefault(Return(CHANNEL_DELETED));
+    ON_CALL(*event_interface_, OnDropChannel(_, _))
+        .WillByDefault(Return(CHANNEL_DELETED));
+  }
+
+  virtual ~WebSocketChannelEventInterfaceTest() {
+    DefaultValue<ChannelState>::Clear();
+  }
 
   // Tests using this fixture must set expectations on the event_interface_ mock
   // object before calling CreateChannelAndConnect() or
   // CreateChannelAndConnectSuccessfully(). This will only work once per test
   // case, but once should be enough.
   virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() OVERRIDE {
     return scoped_ptr<WebSocketEventInterface>(event_interface_.release());
   }
 
   scoped_ptr<MockWebSocketEventInterface> event_interface_;
@@ skipping 27 matching lines @@
       connect_data_.factory;
 
   EXPECT_EQ(&connect_data_.url_request_context, actual.url_request_context);
 
   EXPECT_EQ(connect_data_.socket_url, actual.socket_url);
   EXPECT_EQ(connect_data_.requested_subprotocols,
             actual.requested_subprotocols);
   EXPECT_EQ(connect_data_.origin, actual.origin);
 }
 
-// The documentation for WebSocketEventInterface::OnAddChannelResponse() says
-// that if the first argument is true, ie. the connection failed, then we can
-// safely synchronously delete the WebSocketChannel. This test will only
-// reliably find problems if run with a memory debugger such as
-// AddressSanitizer.
-TEST_F(WebSocketChannelDeletingTest, DeletingFromOnAddChannelResponseWorks) {
+// Any WebSocketEventInterface methods can delete the WebSocketChannel and
+// return CHANNEL_DELETED. The WebSocketChannelDeletingTests are intended to
+// verify that there are no use-after-free bugs when this happens. Problems will
+// probably only be found when running under Address Sanitizer or a similar
+// tool.
+TEST_F(WebSocketChannelDeletingTest, OnAddChannelResponseFail) {
   CreateChannelAndConnect();
+  EXPECT_TRUE(channel_);
   connect_data_.factory.connect_delegate->OnFailure(
       kWebSocketErrorNoStatusReceived);
   EXPECT_EQ(NULL, channel_.get());
 }
 
+// Deletion is possible (due to IPC failure) even if the connect succeeds.
+TEST_F(WebSocketChannelDeletingTest, OnAddChannelResponseSuccess) {
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnDataFrameSync) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "HELLO"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DATA_FRAME;
+
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnDataFrameAsync) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "HELLO"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DATA_FRAME;
+
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_TRUE(channel_);
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnFlowControlAfterConnect) {
+  deleting_ = EVENT_ON_FLOW_CONTROL;
+
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnFlowControlAfterSend) {
+  set_stream(make_scoped_ptr(new WriteableFakeWebSocketStream));
+  // Avoid deleting the channel yet.
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+  CreateChannelAndConnectSuccessfully();
+  ASSERT_TRUE(channel_);
+  deleting_ = EVENT_ON_FLOW_CONTROL;
+  channel_->SendFrame(true,
+                      WebSocketFrameHeader::kOpCodeText,
+                      std::vector<char>(kDefaultInitialQuota, 'B'));
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnClosingHandshakeSync) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_CLOSING_HANDSHAKE;
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnClosingHandshakeAsync) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
+       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_CLOSING_HANDSHAKE;
+  CreateChannelAndConnectSuccessfully();
+  ASSERT_TRUE(channel_);
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnDropChannelWriteError) {
+  set_stream(make_scoped_ptr(new UnWriteableFakeWebSocketStream));
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+  CreateChannelAndConnectSuccessfully();
+  ASSERT_TRUE(channel_);
+  channel_->SendFrame(
+      true, WebSocketFrameHeader::kOpCodeText, AsVector("this will fail"));
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, OnDropChannelReadError) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  stream->PrepareReadFramesError(ReadableFakeWebSocketStream::ASYNC,
+                                 ERR_FAILED);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+  CreateChannelAndConnectSuccessfully();
+  ASSERT_TRUE(channel_);
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, FailChannelInSendFrame) {
+  set_stream(make_scoped_ptr(new WriteableFakeWebSocketStream));
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+  CreateChannelAndConnectSuccessfully();
+  ASSERT_TRUE(channel_);
+  channel_->SendFrame(true,
+                      WebSocketFrameHeader::kOpCodeText,
+                      std::vector<char>(kDefaultInitialQuota * 2, 'T'));
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, FailChannelInOnReadDone) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  stream->PrepareReadFramesError(ReadableFakeWebSocketStream::ASYNC,
+                                 ERR_WS_PROTOCOL_ERROR);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+  CreateChannelAndConnectSuccessfully();
+  ASSERT_TRUE(channel_);
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, FailChannelDueToMaskedFrame) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "HELLO"}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, FailChannelDueToBadControlFrame) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodePong, NOT_MASKED, ""}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, FailChannelDueToPongAfterClose) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+    {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+     CLOSE_DATA(NORMAL_CLOSURE, "Success")},
+    {FINAL_FRAME, WebSocketFrameHeader::kOpCodePong, NOT_MASKED, ""}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
+TEST_F(WebSocketChannelDeletingTest, FailChannelDueToUnknownOpCode) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {{FINAL_FRAME, 0x7, NOT_MASKED, ""}};
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
+  set_stream(stream.Pass());
+  deleting_ = EVENT_ON_DROP_CHANNEL;
+
+  CreateChannelAndConnectSuccessfully();
+  EXPECT_EQ(NULL, channel_.get());
+}
+
 TEST_F(WebSocketChannelEventInterfaceTest, ConnectSuccessReported) {
   // false means success.
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, ""));
   // OnFlowControl is always called immediately after connect to provide initial
   // quota to the renderer.
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
 
   CreateChannelAndConnect();
 
   connect_data_.factory.connect_delegate->OnSuccess(stream_.Pass());
@@ skipping 86 matching lines @@
   CreateChannelAndConnectSuccessfully();
 }
 
 TEST_F(WebSocketChannelEventInterfaceTest, NormalAsyncRead) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "HELLO"}};
   // We use this checkpoint object to verify that the callback isn't called
   // until we expect it to be.
-  MockFunction<void(int)> checkpoint;
+  Checkpoint checkpoint;
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(
         *event_interface_,
         OnDataFrame(
@@ skipping 267 matching lines @@
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("B"));
 }
 
 // If we send enough to go below send_quota_low_water_mask_ we should get our
 // quota refreshed.
 TEST_F(WebSocketChannelEventInterfaceTest, LargeWriteUpdatesQuota) {
   set_stream(make_scoped_ptr(new WriteableFakeWebSocketStream));
   // We use this checkpoint object to verify that the quota update comes after
   // the write.
-  MockFunction<void(int)> checkpoint;
+  Checkpoint checkpoint;
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(2));
   }
 
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
                       std::vector<char>(kDefaultInitialQuota, 'B'));
   checkpoint.Call(2);
 }
 
 // Verify that our quota actually is refreshed when we are told it is.
 TEST_F(WebSocketChannelEventInterfaceTest, QuotaReallyIsRefreshed) {
   set_stream(make_scoped_ptr(new WriteableFakeWebSocketStream));
-  MockFunction<void(int)> checkpoint;
+  Checkpoint checkpoint;
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(2));
     // If quota was not really refreshed, we would get an OnDropChannel()
     // message.
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
@@ skipping 27 matching lines @@
 
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
                       std::vector<char>(kDefaultInitialQuota + 1, 'C'));
 }
 
 // If a write fails, the channel is dropped.
 TEST_F(WebSocketChannelEventInterfaceTest, FailedWrite) {
   set_stream(make_scoped_ptr(new UnWriteableFakeWebSocketStream));
-  MockFunction<void(int)> checkpoint;
+  Checkpoint checkpoint;
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*event_interface_,
                 OnDropChannel(kWebSocketErrorAbnormalClosure, _));
     EXPECT_CALL(checkpoint, Call(2));
   }
 
@@ skipping 154 matching lines @@
   static const InitFrame frames_init[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
        NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
 
   // We store the parameters that were passed to ReadFrames() so that we can
   // call them explicitly later.
   CompletionCallback read_callback;
   ScopedVector<WebSocketFrame>* frames = NULL;
 
   // Use a checkpoint to make the ordering of events clearer.
-  MockFunction<void(int)> checkpoint;
+  Checkpoint checkpoint;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(DoAll(SaveArg<0>(&frames),
                         SaveArg<1>(&read_callback),
                         Return(ERR_IO_PENDING)));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
         .WillOnce(Return(OK));
@@ skipping 98 matching lines @@
 }
 
 // WriteFrames() may not be called until the previous write has completed.
 // WebSocketChannel must buffer writes that happen in the meantime.
 TEST_F(WebSocketChannelStreamTest, WriteFramesOneAtATime) {
   static const InitFrame expected1[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "Hello "}};
   static const InitFrame expected2[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "World"}};
   CompletionCallback write_callback;
-  MockFunction<void(int)> checkpoint;
+  Checkpoint checkpoint;
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
   {
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected1), _))
         .WillOnce(DoAll(SaveArg<1>(&write_callback), Return(ERR_IO_PENDING)));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected2), _))
@@ skipping 160 matching lines @@
       .WillOnce(Return(ERR_WS_PROTOCOL_ERROR));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
   EXPECT_CALL(*mock_stream_, Close());
 
   CreateChannelAndConnectSuccessfully();
 }
 
 }  // namespace
 }  // namespace net