WebSocketFrameChunk should use IOBuffer to hold data

net/websockets/websocket_frame_parser_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/websockets/websocket_frame_parser.h"
 
+#include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "base/port.h"
+#include "net/base/io_buffer.h"
 #include "net/websockets/websocket_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kHello[] = "Hello, world!";
 const uint64 kHelloLength = arraysize(kHello) - 1;
 const char kHelloFrame[] = "\x81\x0DHello, world!";
 const uint64 kHelloFrameLength = arraysize(kHelloFrame) - 1;
 const char kMaskedHelloFrame[] =
@@ skipping 37 matching lines @@
     EXPECT_TRUE(header->final);
     EXPECT_FALSE(header->reserved1);
     EXPECT_FALSE(header->reserved2);
     EXPECT_FALSE(header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_FALSE(header->masked);
     EXPECT_EQ(kHelloLength, header->payload_length);
   }
   EXPECT_TRUE(frame->final_chunk);
 
   std::vector<char> expected_data(kHello, kHello + kHelloLength);

[Yuta Kitamura, 2012/07/27 08:01:08]

expected_data isn't used.

[Takashi Toyoshima, 2012/07/27 10:28:43]

Oops.
Thank you for catching this.

-  EXPECT_EQ(expected_data, frame->data);
+  EXPECT_EQ(kHelloLength, frame->size);
+  EXPECT_TRUE(std::equal(kHello, kHello + kHelloLength, frame->data->data()));
 }
 
 TEST(WebSocketFrameParserTest, DecodeMaskedFrame) {
   WebSocketFrameParser parser;
 
   ScopedVector<WebSocketFrameChunk> frames;
   EXPECT_TRUE(parser.Decode(kMaskedHelloFrame, kMaskedHelloFrameLength,
                             &frames));
   EXPECT_FALSE(parser.failed());
   ASSERT_EQ(1u, frames.size());
   WebSocketFrameChunk* frame = frames[0];
   ASSERT_TRUE(frame != NULL);
   const WebSocketFrameHeader* header = frame->header.get();
   EXPECT_TRUE(header != NULL);
   if (header) {
     EXPECT_TRUE(header->final);
     EXPECT_FALSE(header->reserved1);
     EXPECT_FALSE(header->reserved2);
     EXPECT_FALSE(header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_TRUE(header->masked);
     EXPECT_EQ(kHelloLength, header->payload_length);
   }
   EXPECT_TRUE(frame->final_chunk);
 
-  std::vector<char> expected_data(kHello, kHello + kHelloLength);
-  EXPECT_EQ(expected_data, frame->data);
+  EXPECT_EQ(kHelloLength, frame->size);
+  EXPECT_TRUE(std::equal(kHello, kHello + kHelloLength, frame->data->data()));
 }
 
 TEST(WebSocketFrameParserTest, DecodeManyFrames) {
   struct Input {
     const char* frame;
     size_t frame_length;
     const char* expected_payload;
     size_t expected_payload_length;
   };
   static const Input kInputs[] = {
@@ skipping 28 matching lines @@
   EXPECT_TRUE(parser.Decode(&input.front(), input.size(), &frames));
   EXPECT_FALSE(parser.failed());
   ASSERT_EQ(static_cast<size_t>(kNumInputs), frames.size());
 
   for (int i = 0; i < kNumInputs; ++i) {
     WebSocketFrameChunk* frame = frames[i];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     EXPECT_TRUE(frame->final_chunk);
-    std::vector<char> expected_data(
+    EXPECT_EQ(kInputs[i].expected_payload_length, frame->size);
+    EXPECT_TRUE(std::equal(
         kInputs[i].expected_payload,
-        kInputs[i].expected_payload + kInputs[i].expected_payload_length);
-    EXPECT_EQ(expected_data, frame->data);
+        kInputs[i].expected_payload + kInputs[i].expected_payload_length,
+        frame->data->data()));
 
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_TRUE(header->final);
     EXPECT_FALSE(header->reserved1);
     EXPECT_FALSE(header->reserved2);
     EXPECT_FALSE(header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
@@ skipping 20 matching lines @@
     EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
     EXPECT_FALSE(parser.failed());
     EXPECT_EQ(1u, frames1.size());
     if (frames1.size() != 1u)
       continue;
     WebSocketFrameChunk* frame1 = frames1[0];
     EXPECT_TRUE(frame1 != NULL);
     if (!frame1)
       continue;
     EXPECT_FALSE(frame1->final_chunk);
-    EXPECT_EQ(expected1, frame1->data);
+    EXPECT_EQ(cutting_pos, frame1->size);
+    EXPECT_TRUE(std::equal(expected1.data(),
+                           expected1.data() + expected1.size(),
+                           frame1->data->data()));
     const WebSocketFrameHeader* header1 = frame1->header.get();
     EXPECT_TRUE(header1 != NULL);
     if (!header1)
       continue;
     EXPECT_TRUE(header1->final);
     EXPECT_FALSE(header1->reserved1);
     EXPECT_FALSE(header1->reserved2);
     EXPECT_FALSE(header1->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode);
     EXPECT_FALSE(header1->masked);
     EXPECT_EQ(kHelloLength, header1->payload_length);
 
     ScopedVector<WebSocketFrameChunk> frames2;
     EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
     EXPECT_FALSE(parser.failed());
     EXPECT_EQ(1u, frames2.size());
     if (frames2.size() != 1u)
       continue;
     WebSocketFrameChunk* frame2 = frames2[0];
     EXPECT_TRUE(frame2 != NULL);
     if (!frame2)
       continue;
     EXPECT_TRUE(frame2->final_chunk);
-    EXPECT_EQ(expected2, frame2->data);
+    EXPECT_EQ(expected2.size(), frame2->size);
+    EXPECT_TRUE(std::equal(expected2.data(),
+                           expected2.data() + expected2.size(),
+                           frame2->data->data()));
     const WebSocketFrameHeader* header2 = frame2->header.get();
     EXPECT_TRUE(header2 == NULL);
   }
 }
 
 TEST(WebSocketFrameParserTest, DecodePartialMaskedFrame) {
   static const size_t kFrameHeaderSize = 6;
 
   for (size_t cutting_pos = 0; cutting_pos < kHelloLength; ++cutting_pos) {
     std::vector<char> input1(
@@ skipping 11 matching lines @@
     EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
     EXPECT_FALSE(parser.failed());
     EXPECT_EQ(1u, frames1.size());
     if (frames1.size() != 1u)
       continue;
     WebSocketFrameChunk* frame1 = frames1[0];
     EXPECT_TRUE(frame1 != NULL);
     if (!frame1)
       continue;
     EXPECT_FALSE(frame1->final_chunk);
-    EXPECT_EQ(expected1, frame1->data);
+    EXPECT_EQ(expected1.size(), frame1->size);
+    EXPECT_TRUE(std::equal(expected1.data(),
+                           expected1.data() + expected1.size(),
+                           frame1->data->data()));
     const WebSocketFrameHeader* header1 = frame1->header.get();
     EXPECT_TRUE(header1 != NULL);
     if (!header1)
       continue;
     EXPECT_TRUE(header1->final);
     EXPECT_FALSE(header1->reserved1);
     EXPECT_FALSE(header1->reserved2);
     EXPECT_FALSE(header1->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode);
     EXPECT_TRUE(header1->masked);
     EXPECT_EQ(kHelloLength, header1->payload_length);
 
     ScopedVector<WebSocketFrameChunk> frames2;
     EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
     EXPECT_FALSE(parser.failed());
     EXPECT_EQ(1u, frames2.size());
     if (frames2.size() != 1u)
       continue;
     WebSocketFrameChunk* frame2 = frames2[0];
     EXPECT_TRUE(frame2 != NULL);
     if (!frame2)
       continue;
     EXPECT_TRUE(frame2->final_chunk);
-    EXPECT_EQ(expected2, frame2->data);
+    EXPECT_EQ(expected2.size(), frame2->size);
+    EXPECT_TRUE(std::equal(expected2.data(),
+                           expected2.data() + expected2.size(),
+                           frame2->data->data()));
     const WebSocketFrameHeader* header2 = frame2->header.get();
     EXPECT_TRUE(header2 == NULL);
   }
 }
 
 TEST(WebSocketFrameParserTest, DecodeFramesOfVariousLengths) {
   for (int i = 0; i < kNumFrameHeaderTests; ++i) {
     const char* frame_header = kFrameHeaderTests[i].frame_header;
     size_t frame_header_length = kFrameHeaderTests[i].frame_header_length;
     uint64 frame_length = kFrameHeaderTests[i].frame_length;
@@ skipping 14 matching lines @@
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     if (frame_length == input_payload_size)
       EXPECT_TRUE(frame->final_chunk);
     else
       EXPECT_FALSE(frame->final_chunk);
     std::vector<char> expected_payload(input_payload_size, 'a');
-    EXPECT_EQ(expected_payload, frame->data);
+    EXPECT_EQ(expected_payload.size(), frame->size);
+    EXPECT_TRUE(std::equal(
+        expected_payload.data(),
+        expected_payload.data() + expected_payload.size(),
+        frame->data->data()));
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_TRUE(header->final);
     EXPECT_FALSE(header->reserved1);
     EXPECT_FALSE(header->reserved2);
     EXPECT_FALSE(header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_FALSE(header->masked);
@@ skipping 23 matching lines @@
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     if (frame_length == 0u)
       EXPECT_TRUE(frame->final_chunk);
     else
       EXPECT_FALSE(frame->final_chunk);
-    EXPECT_EQ(std::vector<char>(), frame->data);
+    EXPECT_EQ(0u, frame->size);
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_TRUE(header->final);
     EXPECT_FALSE(header->reserved1);
     EXPECT_FALSE(header->reserved2);
     EXPECT_FALSE(header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_FALSE(header->masked);
@@ skipping 77 matching lines @@
     EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames));
     EXPECT_FALSE(parser.failed());
     EXPECT_EQ(1u, frames.size());
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     EXPECT_TRUE(frame->final_chunk);
-    EXPECT_EQ(std::vector<char>(), frame->data);
+    EXPECT_EQ(0u, frame->size);
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_TRUE(header->final);
     EXPECT_FALSE(header->reserved1);
     EXPECT_FALSE(header->reserved2);
     EXPECT_FALSE(header->reserved3);
     EXPECT_EQ(opcode, header->opcode);
     EXPECT_FALSE(header->masked);
@@ skipping 35 matching lines @@
     EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames));
     EXPECT_FALSE(parser.failed());
     EXPECT_EQ(1u, frames.size());
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     EXPECT_TRUE(frame->final_chunk);
-    EXPECT_EQ(std::vector<char>(), frame->data);
+    EXPECT_EQ(0u, frame->size);
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_EQ(final, header->final);
     EXPECT_EQ(reserved1, header->reserved1);
     EXPECT_EQ(reserved2, header->reserved2);
     EXPECT_EQ(reserved3, header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_FALSE(header->masked);
     EXPECT_EQ(0u, header->payload_length);
   }
 }
 
 }  // namespace net