WebSocketFrameChunk should use IOBuffer to hold data

net/websockets/websocket_frame_parser.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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/big_endian.h"
+#include "net/base/io_buffer.h"
 #include "net/websockets/websocket_frame.h"
 
 namespace {
 
 const uint8 kFinalBit = 0x80;
 const uint8 kReserved1Bit = 0x40;
 const uint8 kReserved2Bit = 0x20;
 const uint8 kReserved3Bit = 0x10;
 const uint8 kOpCodeMask = 0xF;
 const uint8 kMaskBit = 0x80;
@@ skipping 145 matching lines @@
 }
 
 scoped_ptr<WebSocketFrameChunk> WebSocketFrameParser::DecodeFramePayload(
     bool first_chunk) {
   static const int kMaskingKeyLength = WebSocketFrameHeader::kMaskingKeyLength;
 
   const char* current = &buffer_.front() + current_read_pos_;
   const char* end = &buffer_.front() + buffer_.size();
   uint64 next_size = std::min<uint64>(
       end - current,
       current_frame_header_->payload_length - frame_offset_);

[mmenke, 2012/07/27 14:25:55]

Might want to DCHECK_LE(next_size, std::numeric_limits<int>::max());

[Takashi Toyoshima, 2012/07/27 16:08:30]

Done.

 
   scoped_ptr<WebSocketFrameChunk> frame_chunk(new WebSocketFrameChunk);
   if (first_chunk) {
     frame_chunk->header.reset(new WebSocketFrameHeader(*current_frame_header_));
   }
   frame_chunk->final_chunk = false;
-  frame_chunk->data.assign(current, current + next_size);
+  frame_chunk->data = new IOBufferWithSize(next_size);

[mmenke, 2012/07/27 14:25:55]

This doesn't give a warning without casting next_size?

[Takashi Toyoshima, 2012/07/27 16:08:30]

Humm... my local linux build passes it without any warning.
But, as you said, I should apply a casting.

Thanks.

+  DCHECK(frame_chunk->data);

[mmenke, 2012/07/27 14:25:55]

Not needed.  We crash on any allocation failure.

[Takashi Toyoshima, 2012/07/27 16:08:30]

Done.

+  char* io_data = frame_chunk->data->data();
+  memcpy(io_data, current, next_size);
   if (current_frame_header_->masked) {
     // Unmask the payload.
     // TODO(yutak): This could be faster by doing unmasking for each
     // machine word (instead of each byte).
     size_t key_offset = frame_offset_ % kMaskingKeyLength;
     for (uint64 i = 0; i < next_size; ++i) {
-      frame_chunk->data[i] ^= masking_key_[key_offset];
+      io_data[i] ^= masking_key_[key_offset];
       key_offset = (key_offset + 1) % kMaskingKeyLength;
     }
   }
 
   current_read_pos_ += next_size;
   frame_offset_ += next_size;
 
   DCHECK_LE(frame_offset_, current_frame_header_->payload_length);
   if (frame_offset_ == current_frame_header_->payload_length) {
     frame_chunk->final_chunk = true;
     current_frame_header_.reset();
     frame_offset_ = 0;
   }
 
   return frame_chunk.Pass();
 }
 
 }  // namespace net