Change WebSocketChannel to pass data via IOBuffer

net/websockets/websocket_channel_test.cc

Index: net/websockets/websocket_channel_test.cc
diff --git a/net/websockets/websocket_channel_test.cc b/net/websockets/websocket_channel_test.cc
index 5999bbcdba71f6189a2ecb3b4ef17676e33d390b..10ea232eef54701c5db8b0bd5f34b4ff30ba7f82 100644
--- a/net/websockets/websocket_channel_test.cc
+++ b/net/websockets/websocket_channel_test.cc
@@ -158,13 +158,22 @@ class MockWebSocketEventInterface : public WebSocketEventInterface {
  public:
   MockWebSocketEventInterface() {}
 
+  ChannelState OnDataFrame(bool fin,
+                           WebSocketMessageType type,
+                           scoped_refptr<IOBuffer> buffer,
+                           size_t buffer_size) override {
+    const char* data = buffer ? buffer->data() : nullptr;
+    return OnDataFrameVector(fin, type,
+                             std::vector<char>(data, data + buffer_size));
+  }
+
   MOCK_METHOD2(OnAddChannelResponse,
                ChannelState(const std::string&,
                             const std::string&));  // NOLINT
-  MOCK_METHOD3(OnDataFrame,
+  MOCK_METHOD3(OnDataFrameVector,
                ChannelState(bool,
                             WebSocketMessageType,
-                            const std::vector<char>&));  // NOLINT
+                            const std::vector<char>&));           // NOLINT
   MOCK_METHOD1(OnFlowControl, ChannelState(int64_t));             // NOLINT
   MOCK_METHOD0(OnClosingHandshake, ChannelState(void));  // NOLINT
   MOCK_METHOD1(OnFailChannel, ChannelState(const std::string&));  // NOLINT
@@ -208,7 +217,8 @@ class FakeWebSocketEventInterface : public WebSocketEventInterface {
   }
   ChannelState OnDataFrame(bool fin,
                            WebSocketMessageType type,
-                           const std::vector<char>& data) override {
+                           scoped_refptr<IOBuffer> data,
+                           size_t data_size) override {
     return CHANNEL_ALIVE;
   }
   ChannelState OnFlowControl(int64_t quota) override { return CHANNEL_ALIVE; }
@@ -733,13 +743,19 @@ struct WebSocketStreamCreationCallbackArgumentSaver {
   std::unique_ptr<WebSocketStream::ConnectDelegate> connect_delegate;
 };
 
-// Converts a std::string to a std::vector<char>. For test purposes, it is
-// convenient to be able to specify data as a string, but the
-// WebSocketEventInterface requires the vector<char> type.
-std::vector<char> AsVector(const std::string& s) {
+std::vector<char> AsVector(const base::StringPiece& s) {
   return std::vector<char>(s.begin(), s.end());
 }
 
+// Converts a base::StringPiece to a IOBuffer. For test purposes, it is
+// convenient to be able to specify data as a string, but the
+// WebSocketEventInterface requires the IOBuffer type.
+scoped_refptr<IOBuffer> AsIOBuffer(const base::StringPiece& s) {
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(s.size()));
+  std::copy(s.begin(), s.end(), buffer->data());
+  return buffer;
+}
+
 class FakeSSLErrorCallbacks
     : public WebSocketEventInterface::SSLErrorCallbacks {
  public:
@@ -882,7 +898,8 @@ class ChannelDeletingFakeWebSocketEventInterface
 
   ChannelState OnDataFrame(bool fin,
                            WebSocketMessageType type,
-                           const std::vector<char>& data) override {
+                           scoped_refptr<IOBuffer> data,
+                           size_t data_size) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_DATA_FRAME);
   }
 
@@ -1107,9 +1124,9 @@ TEST_F(WebSocketChannelDeletingTest, OnFlowControlAfterSend) {
   CreateChannelAndConnectSuccessfully();
   ASSERT_TRUE(channel_);
   deleting_ = EVENT_ON_FLOW_CONTROL;
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota, 'B'));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer(std::string(kDefaultInitialQuota, 'B')),
+                      kDefaultInitialQuota);
   EXPECT_EQ(nullptr, channel_.get());
 }
 
@@ -1146,8 +1163,8 @@ TEST_F(WebSocketChannelDeletingTest, OnDropChannelWriteError) {
   deleting_ = EVENT_ON_DROP_CHANNEL;
   CreateChannelAndConnectSuccessfully();
   ASSERT_TRUE(channel_);
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("this will fail"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("this will fail"), 14U);
   EXPECT_EQ(nullptr, channel_.get());
 }
 
@@ -1209,9 +1226,9 @@ TEST_F(WebSocketChannelDeletingTest, FailChannelInSendFrame) {
   deleting_ = EVENT_ON_FAIL_CHANNEL;
   CreateChannelAndConnectSuccessfully();
   ASSERT_TRUE(channel_);
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota * 2, 'T'));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer(std::string(kDefaultInitialQuota * 2, 'T')),
+                      kDefaultInitialQuota * 2);
   EXPECT_EQ(nullptr, channel_.get());
 }
 
@@ -1396,10 +1413,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, DataLeftFromHandshake) {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(
-            true, WebSocketFrameHeader::kOpCodeText, AsVector("HELLO")));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("HELLO")));
   }
 
   CreateChannelAndConnectSuccessfully();
@@ -1465,10 +1481,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, NormalAsyncRead) {
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(
-            true, WebSocketFrameHeader::kOpCodeText, AsVector("HELLO")));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("HELLO")));
     EXPECT_CALL(checkpoint, Call(2));
   }
 
@@ -1494,14 +1509,12 @@ TEST_F(WebSocketChannelEventInterfaceTest, AsyncThenSyncRead) {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(
-            true, WebSocketFrameHeader::kOpCodeText, AsVector("HELLO")));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(
-            true, WebSocketFrameHeader::kOpCodeText, AsVector("WORLD")));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("HELLO")));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("WORLD")));
   }
 
   CreateChannelAndConnectSuccessfully();
@@ -1536,26 +1549,25 @@ TEST_F(WebSocketChannelEventInterfaceTest, FragmentedMessage) {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("THREE")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeText, AsVector("THREE")));
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector(" ")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeContinuation, AsVector(" ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("SMALL")));
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("SMALL")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeContinuation, AsVector(" ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("FRAMES")));
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector(" ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("FRAMES")));
   }
 
   CreateChannelAndConnectSuccessfully();
@@ -1574,7 +1586,7 @@ TEST_F(WebSocketChannelEventInterfaceTest, NullMessage) {
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
   EXPECT_CALL(
       *event_interface_,
-      OnDataFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("")));
+      OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText, AsVector("")));
   CreateChannelAndConnectSuccessfully();
 }
 
@@ -1683,14 +1695,13 @@ TEST_F(WebSocketChannelEventInterfaceTest, ControlFrameInDataMessage) {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("SPLIT ")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeText, AsVector("SPLIT ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("MESSAGE")));
+        OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("MESSAGE")));
   }
 
   CreateChannelAndConnectSuccessfully();
@@ -1749,7 +1760,8 @@ TEST_F(WebSocketChannelEventInterfaceTest, SmallWriteDoesntUpdateQuota) {
   }
 
   CreateChannelAndConnectSuccessfully();
-  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("B"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("B"),
+                      1U);
 }
 
 // If we send enough to go below |send_quota_low_water_mark_| we should get our
@@ -1770,9 +1782,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, LargeWriteUpdatesQuota) {
 
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota, 'B'));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer(std::string(kDefaultInitialQuota, 'B')),
+                      kDefaultInitialQuota);
   checkpoint.Call(2);
 }
 
@@ -1795,14 +1807,14 @@ TEST_F(WebSocketChannelEventInterfaceTest, QuotaReallyIsRefreshed) {
 
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultQuotaRefreshTrigger, 'D'));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer(std::string(kDefaultQuotaRefreshTrigger, 'D')),
+                      kDefaultQuotaRefreshTrigger);
   checkpoint.Call(2);
   // We should have received more quota at this point.
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultQuotaRefreshTrigger, 'E'));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer(std::string(kDefaultQuotaRefreshTrigger, 'E')),
+                      kDefaultQuotaRefreshTrigger);
   checkpoint.Call(3);
 }
 
@@ -1818,9 +1830,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, WriteOverQuotaIsRejected) {
   }
 
   CreateChannelAndConnectSuccessfully();
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota + 1, 'C'));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer(std::string(kDefaultInitialQuota + 1, 'C')),
+                      kDefaultInitialQuota + 1);
 }
 
 // If a write fails, the channel is dropped.
@@ -1840,7 +1852,8 @@ TEST_F(WebSocketChannelEventInterfaceTest, FailedWrite) {
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
 
-  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("H"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("H"),
+                      1U);
   checkpoint.Call(2);
 }
 
@@ -1886,7 +1899,8 @@ TEST_F(WebSocketChannelEventInterfaceTest, OnDropChannelCalledOnce) {
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("yt?"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("yt?"), 3U);
   base::RunLoop().RunUntilIdle();
 }
 
@@ -2335,17 +2349,17 @@ TEST_F(WebSocketChannelFlowControlTest, SingleFrameMessageSplitSync) {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("FO")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("FO")));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeContinuation, AsVector("U")));
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("U")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("R")));
+        OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("R")));
   }
 
   CreateChannelAndConnectWithQuota(2);
@@ -2368,19 +2382,19 @@ TEST_F(WebSocketChannelFlowControlTest, SingleFrameMessageSplitAsync) {
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(
-        *event_interface_,
-        OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("FO")));
+    EXPECT_CALL(*event_interface_,
+                OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("FO")));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeContinuation, AsVector("U")));
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("U")));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("R")));
+        OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("R")));
   }
 
   CreateChannelAndConnectWithQuota(2);
@@ -2414,25 +2428,24 @@ TEST_F(WebSocketChannelFlowControlTest, MultipleFrameSplit) {
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeText,
-                            AsVector("FIRST FRAME IS")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector(" 25 BYTES. ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("SECOND FRAME IS 26 BYTES. ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("FINAL ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("FRAME IS 24 BYTES.")));
+                OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("FIRST FRAME IS")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector(" 25 BYTES. ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("SECOND FRAME IS 26 BYTES. ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("FINAL ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("FRAME IS 24 BYTES.")));
   }
   CreateChannelAndConnectWithQuota(14);
   ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(43));
@@ -2457,21 +2470,18 @@ TEST_F(WebSocketChannelFlowControlTest, EmptyMessageNoQuota) {
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeText,
-                            AsVector("FIRST ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("MESSAGE")));
+                OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("FIRST ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("MESSAGE")));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeText,
-                            AsVector("")));
+                OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("")));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeText,
-                            AsVector("THIRD MESSAGE")));
+                OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("THIRD MESSAGE")));
   }
 
   CreateChannelAndConnectWithQuota(6);
@@ -2499,23 +2509,25 @@ TEST_F(WebSocketChannelFlowControlTest, CloseFrameShouldNotOvertakeDataFrames) {
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
   EXPECT_CALL(*event_interface_,
-              OnDataFrame(false, WebSocketFrameHeader::kOpCodeText,
-                          AsVector("FIRST ")));
+              OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                AsVector("FIRST ")));
   EXPECT_CALL(checkpoint, Call(1));
-  EXPECT_CALL(*event_interface_,
-              OnDataFrame(false, WebSocketFrameHeader::kOpCodeContinuation,
-                          AsVector("MESSAG")));
+  EXPECT_CALL(
+      *event_interface_,
+      OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                        AsVector("MESSAG")));
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(*event_interface_,
-              OnDataFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
-                          AsVector("E")));
+              OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeContinuation,
+                                AsVector("E")));
+  EXPECT_CALL(*event_interface_,
+              OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeText,
+                                AsVector("SECON")));
+  EXPECT_CALL(checkpoint, Call(3));
   EXPECT_CALL(
       *event_interface_,
-      OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("SECON")));
-  EXPECT_CALL(checkpoint, Call(3));
-  EXPECT_CALL(*event_interface_,
-              OnDataFrame(false, WebSocketFrameHeader::kOpCodeContinuation,
-                          AsVector("D ")));
+      OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeContinuation,
+                        AsVector("D ")));
   EXPECT_CALL(*event_interface_, OnClosingHandshake());
   EXPECT_CALL(checkpoint, Call(4));
 
@@ -2543,8 +2555,8 @@ TEST_F(WebSocketChannelStreamTest, SentFramesAreMasked) {
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("NEEDS MASKING"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("NEEDS MASKING"), 13U);
 }
 
 // RFC6455 5.5.1 "The application MUST NOT send any more data frames after
@@ -2561,8 +2573,8 @@ TEST_F(WebSocketChannelStreamTest, NothingIsSentAfterClose) {
 
   CreateChannelAndConnectSuccessfully();
   ASSERT_EQ(CHANNEL_ALIVE, channel_->StartClosingHandshake(1000, "Success"));
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("SHOULD  BE IGNORED"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("SHOULD  BE IGNORED"), 18U);
 }
 
 // RFC6455 5.5.1 "If an endpoint receives a Close frame and did not previously
@@ -2803,12 +2815,12 @@ TEST_F(WebSocketChannelStreamTest, PongInTheMiddleOfDataMessage) {
   }
 
   CreateChannelAndConnectSuccessfully();
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("Hello "));
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("Hello "), 6U);
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("World"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
+                      AsIOBuffer("World"), 5U);
 }
 
 // WriteFrames() may not be called until the previous write has completed.
@@ -2837,10 +2849,10 @@ TEST_F(WebSocketChannelStreamTest, WriteFramesOneAtATime) {
 
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("Hello "));
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("World"));
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("Hello "), 6U);
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("World"), 5U);
   checkpoint.Call(2);
   write_callback.Run(OK);
   checkpoint.Call(3);
@@ -2873,9 +2885,8 @@ TEST_F(WebSocketChannelStreamTest, WaitingMessagesAreBatched) {
 
   CreateChannelAndConnectSuccessfully();
   for (size_t i = 0; i < strlen(input_letters); ++i) {
-    channel_->SendFrame(true,
-                        WebSocketFrameHeader::kOpCodeText,
-                        std::vector<char>(1, input_letters[i]));
+    channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                        AsIOBuffer(std::string(1, input_letters[i])), 1U);
   }
   write_callback.Run(OK);
 }
@@ -2894,9 +2905,9 @@ TEST_F(WebSocketChannelStreamTest, SendGoingAwayOnRendererQuotaExceeded) {
   EXPECT_CALL(*mock_stream_, Close());
 
   CreateChannelAndConnectSuccessfully();
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota + 1, 'C'));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer(std::string(kDefaultInitialQuota + 1, 'C')),
+                      kDefaultInitialQuota + 1);
 }
 
 // For convenience, most of these tests use Text frames. However, the WebSocket
@@ -2913,9 +2924,9 @@ TEST_F(WebSocketChannelStreamTest, WrittenBinaryFramesAre8BitClean) {
 
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(
-      true,
-      WebSocketFrameHeader::kOpCodeBinary,
-      std::vector<char>(kBinaryBlob, kBinaryBlob + kBinaryBlobSize));
+      true, WebSocketFrameHeader::kOpCodeBinary,
+      AsIOBuffer(std::string(kBinaryBlob, kBinaryBlob + kBinaryBlobSize)),
+      kBinaryBlobSize);
   ASSERT_TRUE(frames != nullptr);
   ASSERT_EQ(1U, frames->size());
   const WebSocketFrame* out_frame = (*frames)[0].get();
@@ -2942,11 +2953,11 @@ TEST_F(WebSocketChannelEventInterfaceTest, ReadBinaryFramesAre8BitClean) {
   set_stream(std::move(stream));
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
-  EXPECT_CALL(*event_interface_,
-              OnDataFrame(true,
-                          WebSocketFrameHeader::kOpCodeBinary,
-                          std::vector<char>(kBinaryBlob,
-                                            kBinaryBlob + kBinaryBlobSize)));
+  EXPECT_CALL(
+      *event_interface_,
+      OnDataFrameVector(
+          true, WebSocketFrameHeader::kOpCodeBinary,
+          std::vector<char>(kBinaryBlob, kBinaryBlob + kBinaryBlobSize)));
 
   CreateChannelAndConnectSuccessfully();
 }
@@ -2959,8 +2970,8 @@ TEST_F(WebSocketChannelSendUtf8Test, InvalidUtf8Rejected) {
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("\xff"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("\xff"), 1U);
 }
 
 // A Text message cannot end with a partial UTF-8 character.
@@ -2971,8 +2982,8 @@ TEST_F(WebSocketChannelSendUtf8Test, IncompleteCharacterInFinalFrame) {
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("\xc2"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("\xc2"), 1U);
 }
 
 // A non-final Text frame may end with a partial UTF-8 character (compare to
@@ -2980,19 +2991,18 @@ TEST_F(WebSocketChannelSendUtf8Test, IncompleteCharacterInFinalFrame) {
 TEST_F(WebSocketChannelSendUtf8Test, IncompleteCharacterInNonFinalFrame) {
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("\xc2"));
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("\xc2"), 1U);
 }
 
 // UTF-8 parsing context must be retained between frames.
 TEST_F(WebSocketChannelSendUtf8Test, ValidCharacterSplitBetweenFrames) {
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("\xf1"));
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeContinuation,
-                      AsVector("\x80\xa0\xbf"));
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("\xf1"), 1U);
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
+                      AsIOBuffer("\x80\xa0\xbf"), 3U);
 }
 
 // Similarly, an invalid character should be detected even if split.
@@ -3003,11 +3013,10 @@ TEST_F(WebSocketChannelSendUtf8Test, InvalidCharacterSplit) {
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("\xe1"));
-  channel_->SendFrame(true,
-                      WebSocketFrameHeader::kOpCodeContinuation,
-                      AsVector("\x80\xa0\xbf"));
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("\xe1"), 1U);
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
+                      AsIOBuffer("\x80\xa0\xbf"), 3U);
 }
 
 // An invalid character must be detected in continuation frames.
@@ -3018,12 +3027,12 @@ TEST_F(WebSocketChannelSendUtf8Test, InvalidByteInContinuation) {
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("foo"));
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeContinuation, AsVector("bar"));
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("\xff"));
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("foo"), 3U);
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeContinuation,
+                      AsIOBuffer("bar"), 3U);
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
+                      AsIOBuffer("\xff"), 1U);
 }
 
 // However, continuation frames of a Binary frame will not be tested for UTF-8
@@ -3031,12 +3040,12 @@ TEST_F(WebSocketChannelSendUtf8Test, InvalidByteInContinuation) {
 TEST_F(WebSocketChannelSendUtf8Test, BinaryContinuationNotChecked) {
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeBinary, AsVector("foo"));
-  channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeContinuation, AsVector("bar"));
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("\xff"));
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeBinary,
+                      AsIOBuffer("foo"), 3U);
+  channel_->SendFrame(false, WebSocketFrameHeader::kOpCodeContinuation,
+                      AsIOBuffer("bar"), 3U);
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
+                      AsIOBuffer("\xff"), 1U);
 }
 
 // Multiple text messages can be validated without the validation state getting
@@ -3044,8 +3053,10 @@ TEST_F(WebSocketChannelSendUtf8Test, BinaryContinuationNotChecked) {
 TEST_F(WebSocketChannelSendUtf8Test, ValidateMultipleTextMessages) {
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("foo"));
-  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("bar"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("foo"), 3U);
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("bar"), 3U);
 }
 
 // UTF-8 validation is enforced on received Text frames.
@@ -3081,8 +3092,8 @@ TEST_F(WebSocketChannelStreamTest, InvalidUtf8TextFrameNotSent) {
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("\xff"));
+  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("\xff"), 1U);
 }
 
 // The rest of the tests for receiving invalid UTF-8 test the communication with
@@ -3251,10 +3262,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, BogusContinuation) {
 
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(kDefaultInitialQuota));
-  EXPECT_CALL(
-      *event_interface_,
-      OnDataFrame(
-          false, WebSocketFrameHeader::kOpCodeBinary, AsVector("frame1")));
+  EXPECT_CALL(*event_interface_,
+              OnDataFrameVector(false, WebSocketFrameHeader::kOpCodeBinary,
+                                AsVector("frame1")));
   EXPECT_CALL(
       *event_interface_,
       OnFailChannel(
@@ -3298,7 +3308,7 @@ TEST_F(WebSocketChannelEventInterfaceTest, DataFramesNonEmptyOrFinal) {
   EXPECT_CALL(*event_interface_, OnFlowControl(kDefaultInitialQuota));
   EXPECT_CALL(
       *event_interface_,
-      OnDataFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("")));
+      OnDataFrameVector(true, WebSocketFrameHeader::kOpCodeText, AsVector("")));
 
   CreateChannelAndConnectSuccessfully();
 }
@@ -3514,7 +3524,8 @@ TEST_F(WebSocketChannelTest, CurrentSendQuotaUpdated) {
 
   channel_->SendFrame(
       true, WebSocketFrameHeader::kOpCodeText,
-      std::vector<char>(static_cast<size_t>(kMessageSize), 'a'));
+      AsIOBuffer(std::string(static_cast<size_t>(kMessageSize), 'a')),
+      static_cast<size_t>(kMessageSize));
   int new_send_quota = channel_->current_send_quota();
   EXPECT_EQ(kMessageSize, initial_send_quota - new_send_quota);
 }