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 6769de0c9b57e85f36e585f4532693bee0dd2462..4877d244ad49e86a420531797e2e98cf440ab23c 100644
--- a/net/websockets/websocket_channel_test.cc
+++ b/net/websockets/websocket_channel_test.cc
@@ -157,10 +157,20 @@ class MockWebSocketEventInterface : public WebSocketEventInterface {
  public:
   MockWebSocketEventInterface() {}
 
+  ChannelState OnDataFrame(
+      bool fin,
+      WebSocketMessageType type,
+      scoped_refptr<IOBuffer> buffer,
+      size_t buffer_size) override {
+    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
@@ -207,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; }
@@ -732,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:
@@ -881,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);
   }
 
@@ -1108,7 +1126,8 @@ TEST_F(WebSocketChannelDeletingTest, OnFlowControlAfterSend) {
   deleting_ = EVENT_ON_FLOW_CONTROL;
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota, 'B'));
+                      AsIOBuffer(std::string(kDefaultInitialQuota, 'B')),
+                      kDefaultInitialQuota);
   EXPECT_EQ(nullptr, channel_.get());
 }
 
@@ -1145,8 +1164,10 @@ 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());
 }
 
@@ -1210,7 +1231,8 @@ TEST_F(WebSocketChannelDeletingTest, FailChannelInSendFrame) {
   ASSERT_TRUE(channel_);
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota * 2, 'T'));
+                      AsIOBuffer(std::string(kDefaultInitialQuota * 2, 'T')),
+                      kDefaultInitialQuota * 2);
   EXPECT_EQ(nullptr, channel_.get());
 }
 
@@ -1397,7 +1419,7 @@ TEST_F(WebSocketChannelEventInterfaceTest, DataLeftFromHandshake) {
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
+        OnDataFrameVector(
             true, WebSocketFrameHeader::kOpCodeText, AsVector("HELLO")));
   }
 
@@ -1466,7 +1488,7 @@ TEST_F(WebSocketChannelEventInterfaceTest, NormalAsyncRead) {
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
+        OnDataFrameVector(
             true, WebSocketFrameHeader::kOpCodeText, AsVector("HELLO")));
     EXPECT_CALL(checkpoint, Call(2));
   }
@@ -1495,11 +1517,11 @@ TEST_F(WebSocketChannelEventInterfaceTest, AsyncThenSyncRead) {
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
+        OnDataFrameVector(
             true, WebSocketFrameHeader::kOpCodeText, AsVector("HELLO")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
+        OnDataFrameVector(
             true, WebSocketFrameHeader::kOpCodeText, AsVector("WORLD")));
   }
 
@@ -1537,24 +1559,29 @@ TEST_F(WebSocketChannelEventInterfaceTest, FragmentedMessage) {
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeText, AsVector("THREE")));
+        OnDataFrameVector(false,
+                          WebSocketFrameHeader::kOpCodeText,
+                          AsVector("THREE")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeContinuation, AsVector(" ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("SMALL")));
+        OnDataFrameVector(false,
+                          WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector(" ")));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeContinuation, AsVector(" ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("FRAMES")));
+        OnDataFrameVector(false,
+                          WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("SMALL")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(false,
+                          WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector(" ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(true,
+                          WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("FRAMES")));
   }
 
   CreateChannelAndConnectSuccessfully();
@@ -1573,7 +1600,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();
 }
 
@@ -1684,12 +1711,14 @@ TEST_F(WebSocketChannelEventInterfaceTest, ControlFrameInDataMessage) {
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(
-            false, WebSocketFrameHeader::kOpCodeText, AsVector("SPLIT ")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("MESSAGE")));
+        OnDataFrameVector(false,
+                          WebSocketFrameHeader::kOpCodeText,
+                          AsVector("SPLIT ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrameVector(true,
+                          WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("MESSAGE")));
   }
 
   CreateChannelAndConnectSuccessfully();
@@ -1748,7 +1777,10 @@ 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
@@ -1771,7 +1803,8 @@ TEST_F(WebSocketChannelEventInterfaceTest, LargeWriteUpdatesQuota) {
   checkpoint.Call(1);
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota, 'B'));
+                      AsIOBuffer(std::string(kDefaultInitialQuota, 'B')),
+                      kDefaultInitialQuota);
   checkpoint.Call(2);
 }
 
@@ -1796,12 +1829,14 @@ TEST_F(WebSocketChannelEventInterfaceTest, QuotaReallyIsRefreshed) {
   checkpoint.Call(1);
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultQuotaRefreshTrigger, 'D'));
+                      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'));
+                      AsIOBuffer(std::string(kDefaultQuotaRefreshTrigger, 'E')),
+                      kDefaultQuotaRefreshTrigger);
   checkpoint.Call(3);
 }
 
@@ -1819,7 +1854,8 @@ TEST_F(WebSocketChannelEventInterfaceTest, WriteOverQuotaIsRejected) {
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota + 1, 'C'));
+                      AsIOBuffer(std::string(kDefaultInitialQuota + 1, 'C')),
+                      kDefaultInitialQuota + 1);
 }
 
 // If a write fails, the channel is dropped.
@@ -1839,7 +1875,10 @@ 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);
 }
 
@@ -1885,7 +1924,10 @@ TEST_F(WebSocketChannelEventInterfaceTest, OnDropChannelCalledOnce) {
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->SendFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("yt?"));
+  channel_->SendFrame(true,
+                      WebSocketFrameHeader::kOpCodeText,
+                      AsIOBuffer("yt?"),
+                      3U);
   base::RunLoop().RunUntilIdle();
 }
 
@@ -2336,15 +2378,19 @@ TEST_F(WebSocketChannelFlowControlTest, SingleFrameMessageSplitSync) {
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("FO")));
+        OnDataFrameVector(false,
+                          WebSocketFrameHeader::kOpCodeText,
+                          AsVector("FO")));

[Ryan Sleevi, 2016/08/30 08:07:39]

OK, now it totally makes more sense what you were asking w/r/t IOBufferWithSize

If you wanted to avoid the extra casting, you could do something like:

MATCHER_P(BufferAndSize, matcher, "") {
  // or std::vector if you want to use vector matchers
  std::string data(::testing::get<0>(arg)->data(), ::testing::get<1>(arg));
  return matcher.MatchAndExplain(data, result_listener);
}

EXPECT_CALL(
    *event_interface_,
    OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, _)
        .With(::testing::Args<2, 3>(BufferAndSize("FO")));

Arguably, the above code is subtler and assumes even more that readers have
understood the subtlety of
https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md#...


But it does avoid the need to inject your stuff in 160-168, and potentially
allows you to do more complex chains like
.With(::testing::Args<2, 3>(BufferAndSize(AllOf(StartsWith("Hello"),
MatchesRegex("World$")))));

Or using a base::StringPiece matcher, if you wanted to avoid the copy (if you
had more complex cases)

     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);
@@ -2369,17 +2415,21 @@ TEST_F(WebSocketChannelFlowControlTest, SingleFrameMessageSplitAsync) {
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(
         *event_interface_,
-        OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("FO")));
+        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);
@@ -2413,25 +2463,25 @@ 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")));
+                OnDataFrameVector(false,
+                                  WebSocketFrameHeader::kOpCodeText,
+                                  AsVector("FIRST FRAME IS")));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector(" 25 BYTES. ")));
+                OnDataFrameVector(false,
+                                  WebSocketFrameHeader::kOpCodeContinuation,
+                                  AsVector(" 25 BYTES. ")));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("SECOND FRAME IS 26 BYTES. ")));
+                OnDataFrameVector(false,
+                                  WebSocketFrameHeader::kOpCodeContinuation,
+                                  AsVector("SECOND FRAME IS 26 BYTES. ")));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("FINAL ")));
+                OnDataFrameVector(false,
+                                  WebSocketFrameHeader::kOpCodeContinuation,
+                                  AsVector("FINAL ")));
     EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("FRAME IS 24 BYTES.")));
+                OnDataFrameVector(true,
+                                  WebSocketFrameHeader::kOpCodeContinuation,
+                                  AsVector("FRAME IS 24 BYTES.")));
   }
   CreateChannelAndConnectWithQuota(14);
   ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(43));
@@ -2456,21 +2506,21 @@ TEST_F(WebSocketChannelFlowControlTest, EmptyMessageNoQuota) {
     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(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeContinuation,
-                            AsVector("MESSAGE")));
+                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);
@@ -2498,23 +2548,28 @@ 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")));
+              OnDataFrameVector(false,
+                                WebSocketFrameHeader::kOpCodeContinuation,
+                                AsVector("MESSAG")));
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(*event_interface_,
-              OnDataFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
-                          AsVector("E")));
-  EXPECT_CALL(
-      *event_interface_,
-      OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("SECON")));
+              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::kOpCodeContinuation,
-                          AsVector("D ")));
+              OnDataFrameVector(false,
+                                WebSocketFrameHeader::kOpCodeContinuation,
+                                AsVector("D ")));
   EXPECT_CALL(*event_interface_, OnClosingHandshake());
   EXPECT_CALL(checkpoint, Call(4));
 
@@ -2542,8 +2597,10 @@ 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
@@ -2560,8 +2617,10 @@ 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,11 +2862,11 @@ TEST_F(WebSocketChannelStreamTest, PongInTheMiddleOfDataMessage) {
 
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("Hello "));
+      false, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("Hello "), 6U);
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("World"));
+      true, WebSocketFrameHeader::kOpCodeContinuation, AsIOBuffer("World"), 5U);
 }
 
 // WriteFrames() may not be called until the previous write has completed.
@@ -2837,9 +2896,9 @@ TEST_F(WebSocketChannelStreamTest, WriteFramesOneAtATime) {
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("Hello "));
+      false, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("Hello "), 6U);
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("World"));
+      true, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("World"), 5U);
   checkpoint.Call(2);
   write_callback.Run(OK);
   checkpoint.Call(3);
@@ -2874,7 +2933,8 @@ TEST_F(WebSocketChannelStreamTest, WaitingMessagesAreBatched) {
   for (size_t i = 0; i < strlen(input_letters); ++i) {
     channel_->SendFrame(true,
                         WebSocketFrameHeader::kOpCodeText,
-                        std::vector<char>(1, input_letters[i]));
+                        AsIOBuffer(std::string(1, input_letters[i])),
+                        1U);
   }
   write_callback.Run(OK);
 }
@@ -2895,7 +2955,8 @@ TEST_F(WebSocketChannelStreamTest, SendGoingAwayOnRendererQuotaExceeded) {
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
-                      std::vector<char>(kDefaultInitialQuota + 1, 'C'));
+                      AsIOBuffer(std::string(kDefaultInitialQuota + 1, 'C')),
+                      kDefaultInitialQuota + 1);
 }
 
 // For convenience, most of these tests use Text frames. However, the WebSocket
@@ -2914,7 +2975,8 @@ TEST_F(WebSocketChannelStreamTest, WrittenBinaryFramesAre8BitClean) {
   channel_->SendFrame(
       true,
       WebSocketFrameHeader::kOpCodeBinary,
-      std::vector<char>(kBinaryBlob, kBinaryBlob + kBinaryBlobSize));
+      AsIOBuffer(std::string(kBinaryBlob, kBinaryBlob + kBinaryBlobSize)),
+      kBinaryBlobSize);
   ASSERT_TRUE(frames != nullptr);
   ASSERT_EQ(1U, frames->size());
   const WebSocketFrame* out_frame = (*frames)[0].get();
@@ -2941,11 +3003,12 @@ 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,7 +3022,7 @@ TEST_F(WebSocketChannelSendUtf8Test, InvalidUtf8Rejected) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("\xff"));
+      true, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("\xff"), 1U);
 }
 
 // A Text message cannot end with a partial UTF-8 character.
@@ -2971,7 +3034,7 @@ TEST_F(WebSocketChannelSendUtf8Test, IncompleteCharacterInFinalFrame) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("\xc2"));
+      true, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("\xc2"), 1U);
 }
 
 // A non-final Text frame may end with a partial UTF-8 character (compare to
@@ -2980,7 +3043,7 @@ TEST_F(WebSocketChannelSendUtf8Test, IncompleteCharacterInNonFinalFrame) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("\xc2"));
+      false, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("\xc2"), 1U);
 }
 
 // UTF-8 parsing context must be retained between frames.
@@ -2988,10 +3051,11 @@ TEST_F(WebSocketChannelSendUtf8Test, ValidCharacterSplitBetweenFrames) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("\xf1"));
+      false, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("\xf1"), 1U);
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeContinuation,
-                      AsVector("\x80\xa0\xbf"));
+                      AsIOBuffer("\x80\xa0\xbf"),
+                      3U);
 }
 
 // Similarly, an invalid character should be detected even if split.
@@ -3003,10 +3067,11 @@ TEST_F(WebSocketChannelSendUtf8Test, InvalidCharacterSplit) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("\xe1"));
+      false, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("\xe1"), 1U);
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeContinuation,
-                      AsVector("\x80\xa0\xbf"));
+                      AsIOBuffer("\x80\xa0\xbf"),
+                      3U);
 }
 
 // An invalid character must be detected in continuation frames.
@@ -3018,11 +3083,11 @@ TEST_F(WebSocketChannelSendUtf8Test, InvalidByteInContinuation) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeText, AsVector("foo"));
+      false, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("foo"), 3U);
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeContinuation, AsVector("bar"));
+      false, WebSocketFrameHeader::kOpCodeContinuation, AsIOBuffer("bar"), 3U);
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("\xff"));
+      true, WebSocketFrameHeader::kOpCodeContinuation, AsIOBuffer("\xff"), 1U);
 }
 
 // However, continuation frames of a Binary frame will not be tested for UTF-8
@@ -3031,11 +3096,11 @@ TEST_F(WebSocketChannelSendUtf8Test, BinaryContinuationNotChecked) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeBinary, AsVector("foo"));
+      false, WebSocketFrameHeader::kOpCodeBinary, AsIOBuffer("foo"), 3U);
   channel_->SendFrame(
-      false, WebSocketFrameHeader::kOpCodeContinuation, AsVector("bar"));
+      false, WebSocketFrameHeader::kOpCodeContinuation, AsIOBuffer("bar"), 3U);
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("\xff"));
+      true, WebSocketFrameHeader::kOpCodeContinuation, AsIOBuffer("\xff"), 1U);
 }
 
 // Multiple text messages can be validated without the validation state getting
@@ -3043,8 +3108,14 @@ 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,7 +3152,7 @@ TEST_F(WebSocketChannelStreamTest, InvalidUtf8TextFrameNotSent) {
   CreateChannelAndConnectSuccessfully();
 
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText, AsVector("\xff"));
+      true, WebSocketFrameHeader::kOpCodeText, AsIOBuffer("\xff"), 1U);
 }
 
 // The rest of the tests for receiving invalid UTF-8 test the communication with
@@ -3252,8 +3323,9 @@ TEST_F(WebSocketChannelEventInterfaceTest, BogusContinuation) {
   EXPECT_CALL(*event_interface_, OnFlowControl(kDefaultInitialQuota));
   EXPECT_CALL(
       *event_interface_,
-      OnDataFrame(
-          false, WebSocketFrameHeader::kOpCodeBinary, AsVector("frame1")));
+      OnDataFrameVector(false,
+                        WebSocketFrameHeader::kOpCodeBinary,
+                        AsVector("frame1")));
   EXPECT_CALL(
       *event_interface_,
       OnFailChannel(
@@ -3297,7 +3369,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();
 }
@@ -3512,8 +3584,10 @@ TEST_F(WebSocketChannelTest, CurrentSendQuotaUpdated) {
   EXPECT_GE(initial_send_quota, kMessageSize);
 
   channel_->SendFrame(
-      true, WebSocketFrameHeader::kOpCodeText,
-      std::vector<char>(static_cast<size_t>(kMessageSize), 'a'));
+      true,
+      WebSocketFrameHeader::kOpCodeText,
+      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);
 }