ABANDONED CL: Rename readyState() to getReadyState().

third_party/WebKit/Source/modules/websockets/DOMWebSocketTest.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 "modules/websockets/DOMWebSocket.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/DOMTypedArray.h"
@@ skipping 121 matching lines @@
 
 TEST(DOMWebSocketTest, connectToBadURL) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   webSocketScope.socket().connect("xxx", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(SyntaxError, scope.getExceptionState().code());
   EXPECT_EQ("The URL 'xxx' is invalid.", scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, connectToNonWsURL) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   webSocketScope.socket().connect("http://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(SyntaxError, scope.getExceptionState().code());
   EXPECT_EQ(
       "The URL's scheme must be either 'ws' or 'wss'. 'http' is not allowed.",
       scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, connectToURLHavingFragmentIdentifier) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   webSocketScope.socket().connect("ws://example.com/#fragment",
                                   Vector<String>(), scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(SyntaxError, scope.getExceptionState().code());
   EXPECT_EQ(
       "The URL contains a fragment identifier ('fragment'). Fragment "
       "identifiers are not allowed in WebSocket URLs.",
       scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, invalidPort) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   webSocketScope.socket().connect("ws://example.com:7", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(SecurityError, scope.getExceptionState().code());
   EXPECT_EQ("The port 7 is not allowed.", scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 // FIXME: Add a test for Content Security Policy.
 
 TEST(DOMWebSocketTest, invalidSubprotocols) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   Vector<String> subprotocols;
   subprotocols.append("@subprotocol-|'\"x\x01\x02\x03x");
 
   webSocketScope.socket().connect("ws://example.com/", subprotocols,
                                   scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(SyntaxError, scope.getExceptionState().code());
   EXPECT_EQ(
       "The subprotocol '@subprotocol-|'\"x\\u0001\\u0002\\u0003x' is invalid.",
       scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, insecureRequestsUpgrade) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "wss://example.com/endpoint"), String()))
         .WillOnce(Return(true));
   }
 
   scope.document().setInsecureRequestPolicy(kUpgradeInsecureRequests);
   webSocketScope.socket().connect("ws://example.com/endpoint", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
   EXPECT_EQ(KURL(KURL(), "wss://example.com/endpoint"),
             webSocketScope.socket().url());
 }
 
 TEST(DOMWebSocketTest, insecureRequestsDoNotUpgrade) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/endpoint"), String()))
         .WillOnce(Return(true));
   }
 
   scope.document().setInsecureRequestPolicy(kLeaveInsecureRequestsAlone);
   webSocketScope.socket().connect("ws://example.com/endpoint", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
   EXPECT_EQ(KURL(KURL(), "ws://example.com/endpoint"),
             webSocketScope.socket().url());
 }
 
 TEST(DOMWebSocketTest, channelConnectSuccess) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   Vector<String> subprotocols;
   subprotocols.append("aa");
   subprotocols.append("bb");
 
   {
     InSequence s;
     EXPECT_CALL(
         webSocketScope.channel(),
         connect(KURL(KURL(), "ws://example.com/hoge"), String("aa, bb")))
         .WillOnce(Return(true));
   }
 
   webSocketScope.socket().connect("ws://example.com/hoge",
                                   Vector<String>(subprotocols),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
   EXPECT_EQ(KURL(KURL(), "ws://example.com/hoge"),
             webSocketScope.socket().url());
 }
 
 TEST(DOMWebSocketTest, channelConnectFail) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   Vector<String> subprotocols;
   subprotocols.append("aa");
   subprotocols.append("bb");
 
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String("aa, bb")))
         .WillOnce(Return(false));
     EXPECT_CALL(webSocketScope.channel(), disconnect());
   }
 
   webSocketScope.socket().connect("ws://example.com/",
                                   Vector<String>(subprotocols),
                                   scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(SecurityError, scope.getExceptionState().code());
   EXPECT_EQ(
       "An insecure WebSocket connection may not be initiated from a page "
       "loaded over HTTPS.",
       scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, isValidSubprotocolString) {
   EXPECT_TRUE(DOMWebSocket::isValidSubprotocolString("Helloworld!!"));
   EXPECT_FALSE(DOMWebSocket::isValidSubprotocolString("Hello, world!!"));
   EXPECT_FALSE(DOMWebSocket::isValidSubprotocolString(String()));
   EXPECT_FALSE(DOMWebSocket::isValidSubprotocolString(""));
 
   const char validCharacters[] =
       "!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`"
@@ skipping 24 matching lines @@
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String("aa, bb")))
         .WillOnce(Return(true));
   }
   webSocketScope.socket().connect("ws://example.com/", subprotocols,
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didConnect("bb", "cc");
 
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
   EXPECT_EQ("bb", webSocketScope.socket().protocol());
   EXPECT_EQ("cc", webSocketScope.socket().extensions());
 }
 
 TEST(DOMWebSocketTest, didClose) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), disconnect());
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didClose(
       WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
 
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, maximumReasonSize) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), failMock(_, _, _));
   }
   StringBuilder reason;
   for (size_t i = 0; i < 123; ++i)
     reason.append('a');
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().close(1000, reason.toString(),
                                 scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, reasonSizeExceeding) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
   }
   StringBuilder reason;
   for (size_t i = 0; i < 124; ++i)
     reason.append('a');
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().close(1000, reason.toString(),
                                 scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(SyntaxError, scope.getExceptionState().code());
   EXPECT_EQ("The message must not be greater than 123 bytes.",
             scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, closeWhenConnecting) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(
         webSocketScope.channel(),
         failMock(
             String("WebSocket is closed before the connection is established."),
             WarningMessageLevel, _));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().close(1000, "bye", scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, close) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), close(3005, String("bye")));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didConnect("", "");
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
   webSocketScope.socket().close(3005, "bye", scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, closeWithoutReason) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), close(3005, String()));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didConnect("", "");
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
   webSocketScope.socket().close(3005, scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, closeWithoutCodeAndReason) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), close(-1, String()));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didConnect("", "");
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
   webSocketScope.socket().close(scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, closeWhenClosing) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), close(-1, String()));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didConnect("", "");
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
   webSocketScope.socket().close(scope.getExceptionState());
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().close(scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, closeWhenClosed) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), close(-1, String()));
     EXPECT_CALL(webSocketScope.channel(), disconnect());
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didConnect("", "");
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
   webSocketScope.socket().close(scope.getExceptionState());
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().didClose(
       WebSocketChannelClient::ClosingHandshakeComplete, 1000, String());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
   webSocketScope.socket().close(scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendStringWhenConnecting) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().send("hello", scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(InvalidStateError, scope.getExceptionState().code());
   EXPECT_EQ("Still in CONNECTING state.", scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendStringWhenClosing) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   Checkpoint checkpoint;
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), failMock(_, _, _));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().close(scope.getExceptionState());
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().send("hello", scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendStringWhenClosed) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   Checkpoint checkpoint;
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), disconnect());
     EXPECT_CALL(checkpoint, Call(1));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().didClose(
       WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
   checkpoint.Call(1);
 
   webSocketScope.socket().send("hello", scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendStringSuccess) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), send(CString("hello")));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().didConnect("", "");
   webSocketScope.socket().send("hello", scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendNonLatin1String) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(),
                 send(CString("\xe7\x8b\x90\xe0\xa4\x94")));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().didConnect("", "");
   UChar nonLatin1String[] = {0x72d0, 0x0914, 0x0000};
   webSocketScope.socket().send(nonLatin1String, scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendArrayBufferWhenConnecting) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   DOMArrayBufferView* view = DOMUint8Array::create(8);
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().send(view->buffer(), scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(InvalidStateError, scope.getExceptionState().code());
   EXPECT_EQ("Still in CONNECTING state.", scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendArrayBufferWhenClosing) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   DOMArrayBufferView* view = DOMUint8Array::create(8);
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), failMock(_, _, _));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().close(scope.getExceptionState());
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().send(view->buffer(), scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendArrayBufferWhenClosed) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   Checkpoint checkpoint;
   DOMArrayBufferView* view = DOMUint8Array::create(8);
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), disconnect());
     EXPECT_CALL(checkpoint, Call(1));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().didClose(
       WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
   checkpoint.Call(1);
 
   webSocketScope.socket().send(view->buffer(), scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosed, webSocketScope.socket().getReadyState());
 }
 
 TEST(DOMWebSocketTest, sendArrayBufferSuccess) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   DOMArrayBufferView* view = DOMUint8Array::create(8);
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), send(Ref(*view->buffer()), 0, 8));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
 
   webSocketScope.socket().didConnect("", "");
   webSocketScope.socket().send(view->buffer(), scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kOpen, webSocketScope.socket().getReadyState());
 }
 
 // FIXME: We should have Blob tests here.
 // We can't create a Blob because the blob registration cannot be mocked yet.
 
 // FIXME: We should add tests for bufferedAmount.
 
 // FIXME: We should add tests for data receiving.
 
 TEST(DOMWebSocketTest, binaryType) {
@@ skipping 22 matching lines @@
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
     EXPECT_CALL(webSocketScope.channel(), failMock(_, _, _));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().close(GetParam(), "bye", scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kClosing, webSocketScope.socket().getReadyState());
 }
 
 INSTANTIATE_TEST_CASE_P(DOMWebSocketValidClosing,
                         DOMWebSocketValidClosingTest,
                         ::testing::Values(1000, 3000, 3001, 4998, 4999));
 
 class DOMWebSocketInvalidClosingCodeTest
     : public ::testing::TestWithParam<unsigned short> {};
 
 TEST_P(DOMWebSocketInvalidClosingCodeTest, test) {
   V8TestingScope scope;
   DOMWebSocketTestScope webSocketScope(scope.getExecutionContext());
   {
     InSequence s;
     EXPECT_CALL(webSocketScope.channel(),
                 connect(KURL(KURL(), "ws://example.com/"), String()))
         .WillOnce(Return(true));
   }
   webSocketScope.socket().connect("ws://example.com/", Vector<String>(),
                                   scope.getExceptionState());
 
   EXPECT_FALSE(scope.getExceptionState().hadException());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 
   webSocketScope.socket().close(GetParam(), "bye", scope.getExceptionState());
 
   EXPECT_TRUE(scope.getExceptionState().hadException());
   EXPECT_EQ(InvalidAccessError, scope.getExceptionState().code());
   EXPECT_EQ(String::format("The code must be either 1000, or between 3000 and "
                            "4999. %d is neither.",
                            GetParam()),
             scope.getExceptionState().message());
-  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().readyState());
+  EXPECT_EQ(DOMWebSocket::kConnecting, webSocketScope.socket().getReadyState());
 }
 
 INSTANTIATE_TEST_CASE_P(
     DOMWebSocketInvalidClosingCode,
     DOMWebSocketInvalidClosingCodeTest,
     ::testing::Values(0, 1, 998, 999, 1001, 2999, 5000, 9999, 65535));
 
 }  // namespace
 
 }  // namespace blink