Oilpan: fix WebSocket unit tests memory leaks.

Source/modules/websockets/WebSocketTest.cpp

 // Copyright 2014 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 "config.h"
 
 #include "modules/websockets/WebSocket.h"
 
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/V8Binding.h"
@@ skipping 52 matching lines @@
     {
     }
 };
 
 class WebSocketWithMockChannel FINAL : public WebSocket {
 public:
     static PassRefPtrWillBeRawPtr<WebSocketWithMockChannel> create(ExecutionContext* context)
     {
         RefPtrWillBeRawPtr<WebSocketWithMockChannel> websocket = adoptRefWillBeRefCountedGarbageCollected(new WebSocketWithMockChannel(context));
         websocket->suspendIfNeeded();
-        return websocket;
+        return websocket.release();
     }
 
     MockWebSocketChannel* channel() { return m_channel.get(); }
 
     virtual PassRefPtrWillBeRawPtr<WebSocketChannel> createChannel(ExecutionContext*, WebSocketChannelClient*) OVERRIDE
     {
         ASSERT(!m_hasCreatedChannel);
         m_hasCreatedChannel = true;
         return m_channel.get();
     }
 
     virtual void trace(Visitor* visitor) OVERRIDE
     {
         visitor->trace(m_channel);
         WebSocket::trace(visitor);
     }
 
 private:
     WebSocketWithMockChannel(ExecutionContext* context)
-        : WebSocket(context), m_channel(MockWebSocketChannel::create()), m_hasCreatedChannel(false) { }
+        : WebSocket(context)
+        , m_channel(MockWebSocketChannel::create())
+        , m_hasCreatedChannel(false) { }
 
     RefPtrWillBeMember<MockWebSocketChannel> m_channel;
     bool m_hasCreatedChannel;
 };
 
 class WebSocketTestBase {
 public:
     WebSocketTestBase()
         : m_pageHolder(DummyPageHolder::create())
         , m_websocket(WebSocketWithMockChannel::create(&m_pageHolder->document()))
-        , m_channel(m_websocket->channel())
         , m_executionScope(v8::Isolate::GetCurrent())
         , m_exceptionState(ExceptionState::ConstructionContext, "property", "interface", m_executionScope.scriptState()->context()->Global(), m_executionScope.isolate())
     {
     }
 
     virtual ~WebSocketTestBase()
     {
         if (!m_websocket)
             return;
         // These statements are needed to clear WebSocket::m_channel to
         // avoid ASSERTION failure on ~WebSocket.
-        ASSERT(m_channel);
-        ::testing::Mock::VerifyAndClear(m_channel.get());
-        EXPECT_CALL(*m_channel, disconnect()).Times(AnyNumber());
+        ASSERT(m_websocket->channel());
+        ::testing::Mock::VerifyAndClear(m_websocket->channel());
+        EXPECT_CALL(channel(), disconnect()).Times(AnyNumber());
 
         m_websocket->didClose(0, WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
+        m_websocket.clear();
+        Heap::collectAllGarbage();
     }
 
+    MockWebSocketChannel& channel() { return *m_websocket->channel(); }
+
     OwnPtr<DummyPageHolder> m_pageHolder;
     RefPtrWillBePersistent<WebSocketWithMockChannel> m_websocket;
-    RefPtrWillBePersistent<MockWebSocketChannel> m_channel;
     V8TestingScope m_executionScope;
     ExceptionState m_exceptionState;
 };
 
 class WebSocketTest : public WebSocketTestBase, public ::testing::Test {
 public:
 };
 
 TEST_F(WebSocketTest, connectToBadURL)
 {
@@ skipping 41 matching lines @@
 
 // FIXME: Add a test for Content Security Policy.
 
 TEST_F(WebSocketTest, invalidSubprotocols)
 {
     Vector<String> subprotocols;
     subprotocols.append("@subprotocol-|'\"x\x01\x02\x03x");
 
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, disconnect());
+        EXPECT_CALL(channel(), disconnect());
     }
 
     m_websocket->connect("ws://example.com/", subprotocols, m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(SyntaxError, m_exceptionState.code());
     EXPECT_EQ("The subprotocol '@subprotocol-|'\"x\\u0001\\u0002\\u0003x' is invalid.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, channelConnectSuccess)
 {
     Vector<String> subprotocols;
     subprotocols.append("aa");
     subprotocols.append("bb");
 
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/hoge"), String("aa, bb"))).WillOnce(Return(true));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/hoge"), String("aa, bb"))).WillOnce(Return(true));
     }
 
     m_websocket->connect("ws://example.com/hoge", Vector<String>(subprotocols), m_exceptionState);
 
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
     EXPECT_EQ(KURL(KURL(), "ws://example.com/hoge"), m_websocket->url());
 }
 
 TEST_F(WebSocketTest, channelConnectFail)
 {
     Vector<String> subprotocols;
     subprotocols.append("aa");
     subprotocols.append("bb");
 
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String("aa, bb"))).WillOnce(Return(false));
-        EXPECT_CALL(*m_channel, disconnect());
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String("aa, bb"))).WillOnce(Return(false));
+        EXPECT_CALL(channel(), disconnect());
     }
 
     m_websocket->connect("ws://example.com/", Vector<String>(subprotocols), m_exceptionState);
 
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(SecurityError, m_exceptionState.code());
     EXPECT_EQ("An insecure WebSocket connection may not be initiated from a page loaded over HTTPS.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
@@ skipping 22 matching lines @@
     }
 }
 
 TEST_F(WebSocketTest, connectSuccess)
 {
     Vector<String> subprotocols;
     subprotocols.append("aa");
     subprotocols.append("bb");
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String("aa, bb"))).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String("bb")));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String("cc")));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String("aa, bb"))).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String("bb")));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String("cc")));
     }
     m_websocket->connect("ws://example.com/", subprotocols, m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->didConnect();
 
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     EXPECT_EQ("bb", m_websocket->protocol());
     EXPECT_EQ("cc", m_websocket->extensions());
 }
 
 TEST_F(WebSocketTest, didClose)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, disconnect());
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), disconnect());
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->didClose(0, WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
 
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, maximumReasonSize)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, fail(_, _, _, _));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), fail(_, _, _, _));
     }
     String reason;
     for (size_t i = 0; i < 123; ++i)
         reason.append("a");
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->close(1000, reason, m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, reasonSizeExceeding)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
     }
     String reason;
     for (size_t i = 0; i < 124; ++i)
         reason.append("a");
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->close(1000, reason, m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(SyntaxError, m_exceptionState.code());
     EXPECT_EQ("The message must not be greater than 123 bytes.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWhenConnecting)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, fail(String("WebSocket is closed before the connection is established."), WarningMessageLevel, String(), 0));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), fail(String("WebSocket is closed before the connection is established."), WarningMessageLevel, String(), 0));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->close(1000, "bye", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, close)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, close(3005, String("bye")));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), close(3005, String("bye")));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->didConnect();
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(3005, "bye", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWithoutReason)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, close(3005, String()));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), close(3005, String()));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->didConnect();
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(3005, m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWithoutCodeAndReason)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, close(-1, String()));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), close(-1, String()));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->didConnect();
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWhenClosing)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, close(-1, String()));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), close(-1, String()));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->didConnect();
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 
     m_websocket->close(m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWhenClosed)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, close(-1, String()));
-        EXPECT_CALL(*m_channel, disconnect());
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), close(-1, String()));
+        EXPECT_CALL(channel(), disconnect());
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->didConnect();
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 
     m_websocket->didClose(0, WebSocketChannelClient::ClosingHandshakeComplete, 1000, String());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringWhenConnecting)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(InvalidStateError, m_exceptionState.code());
     EXPECT_EQ("Still in CONNECTING state.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringWhenClosing)
 {
     Checkpoint checkpoint;
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, fail(_, _, _, _));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), fail(_, _, _, _));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->close(m_exceptionState);
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringWhenClosed)
 {
     Checkpoint checkpoint;
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, disconnect());
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), disconnect());
         EXPECT_CALL(checkpoint, Call(1));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didClose(0, WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
     checkpoint.Call(1);
 
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringSuccess)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, send(String("hello"))).WillOnce(Return(WebSocketChannel::SendSuccess));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), send(String("hello"))).WillOnce(Return(WebSocketChannel::SendSuccess));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didConnect();
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringFail)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, send(String("hello"))).WillOnce(Return(WebSocketChannel::SendFail));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), send(String("hello"))).WillOnce(Return(WebSocketChannel::SendFail));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didConnect();
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringInvalidMessage)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, send(String("hello"))).WillOnce(Return(WebSocketChannel::InvalidMessage));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), send(String("hello"))).WillOnce(Return(WebSocketChannel::InvalidMessage));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didConnect();
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(SyntaxError, m_exceptionState.code());
     EXPECT_EQ("The message contains invalid characters.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferWhenConnecting)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(InvalidStateError, m_exceptionState.code());
     EXPECT_EQ("Still in CONNECTING state.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferWhenClosing)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, fail(_, _, _, _));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), fail(_, _, _, _));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->close(m_exceptionState);
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferWhenClosed)
 {
     Checkpoint checkpoint;
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, disconnect());
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), disconnect());
         EXPECT_CALL(checkpoint, Call(1));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didClose(0, WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
     checkpoint.Call(1);
 
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferSuccess)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::SendSuccess));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::SendSuccess));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didConnect();
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferFail)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::SendFail));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::SendFail));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didConnect();
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferInvalidMessage)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, extensions()).WillOnce(Return(String()));
-        EXPECT_CALL(*m_channel, send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::InvalidMessage));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
+        EXPECT_CALL(channel(), send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::InvalidMessage));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
     m_websocket->didConnect();
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(SyntaxError, m_exceptionState.code());
@@ skipping 32 matching lines @@
 // FIXME: We should add tests for suspend / resume.
 
 class WebSocketValidClosingCodeTest : public WebSocketTestBase, public ::testing::TestWithParam<unsigned short> {
 public:
 };
 
 TEST_P(WebSocketValidClosingCodeTest, test)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(*m_channel, fail(_, _, _, _));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), fail(_, _, _, _));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->close(GetParam(), "bye", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 INSTANTIATE_TEST_CASE_P(WebSocketValidClosingCode, WebSocketValidClosingCodeTest, ::testing::Values(1000, 3000, 3001, 4998, 4999));
 
 class WebSocketInvalidClosingCodeTest : public WebSocketTestBase, public ::testing::TestWithParam<unsigned short> {
 public:
 };
 
 TEST_P(WebSocketInvalidClosingCodeTest, test)
 {
     {
         InSequence s;
-        EXPECT_CALL(*m_channel, connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
+        EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
     m_websocket->close(GetParam(), "bye", m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(InvalidAccessError, m_exceptionState.code());
     EXPECT_EQ(String::format("The code must be either 1000, or between 3000 and 4999. %d is neither.", GetParam()), m_exceptionState.message());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 }
 
 INSTANTIATE_TEST_CASE_P(WebSocketInvalidClosingCode, WebSocketInvalidClosingCodeTest, ::testing::Values(0, 1, 998, 999, 1001, 2999, 5000, 9999, 65535));
 
 } // namespace
 
 } // namespace WebCore