Replace WebSocketFrameChunk with WebSocketFrame

net/websockets/websocket_frame.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.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 23 matching lines @@
     *masked ^= masking_key.key[masking_key_offset++];
     if (masking_key_offset == net::WebSocketFrameHeader::kMaskingKeyLength)
       masking_key_offset = 0;
   }
 }
 
 }  // Unnamed namespace.
 
 namespace net {
 
-scoped_ptr<WebSocketFrameHeader> WebSocketFrameHeader::Clone() {
+scoped_ptr<WebSocketFrameHeader> WebSocketFrameHeader::Clone() const {
   scoped_ptr<WebSocketFrameHeader> ret(new WebSocketFrameHeader(opcode));
-  ret->final = final;
-  ret->reserved1 = reserved1;
-  ret->reserved2 = reserved2;
-  ret->reserved3 = reserved3;
-  ret->opcode = opcode;
-  ret->masked = masked;
-  ret->payload_length = payload_length;
+  ret->CopyFrom(*this);
   return ret.Pass();
 }
 
+void WebSocketFrameHeader::CopyFrom(const WebSocketFrameHeader& source) {
+  final = source.final;
+  reserved1 = source.reserved1;
+  reserved2 = source.reserved2;
+  reserved3 = source.reserved3;
+  opcode = source.opcode;
+  masked = source.masked;
+  payload_length = source.payload_length;
+}
+
+WebSocketFrame::WebSocketFrame(WebSocketFrameHeader::OpCode opcode)
+    : header(opcode) {}
+
+WebSocketFrame::~WebSocketFrame() {}
+
 WebSocketFrameChunk::WebSocketFrameChunk() : final_chunk(false) {}
 
 WebSocketFrameChunk::~WebSocketFrameChunk() {}
 
 int GetWebSocketFrameHeaderSize(const WebSocketFrameHeader& header) {
   int extended_length_size = 0;
   if (header.payload_length > kMaxPayloadLengthWithoutExtendedLengthField &&
       header.payload_length <= kuint16max) {
     extended_length_size = 2;
   } else if (header.payload_length > kuint16max) {
@@ skipping 122 matching lines @@
   DCHECK(aligned_begin < end);
   MaskWebSocketFramePayloadByBytes(
       masking_key, frame_offset % kMaskingKeyLength, data, aligned_begin);
   const size_t end_modulus = reinterpret_cast<size_t>(end) % kPackedMaskKeySize;
   char* const aligned_end = end - end_modulus;
   // Guaranteed by the above check for small data_size.
   DCHECK(aligned_end > aligned_begin);
   // Create a version of the mask which is rotated by the appropriate offset
   // for our alignment. The "trick" here is that 0 XORed with the mask will
   // give the value of the mask for the appropriate byte.
-  char realigned_mask[kMaskingKeyLength] = { 0 };
+  char realigned_mask[kMaskingKeyLength] = {};
   MaskWebSocketFramePayloadByBytes(
       masking_key,
       (frame_offset + aligned_begin - data) % kMaskingKeyLength,
       realigned_mask,
       realigned_mask + kMaskingKeyLength);
 
   for (size_t i = 0; i < kPackedMaskKeySize; i += kMaskingKeyLength) {
     // memcpy() is allegedly blessed by the C++ standard for type-punning.
     memcpy(reinterpret_cast<char*>(&packed_mask_key) + i,
            realigned_mask,
@@ skipping 12 matching lines @@
   }
 
   MaskWebSocketFramePayloadByBytes(
       masking_key,
       (frame_offset + (aligned_end - data)) % kMaskingKeyLength,
       aligned_end,
       end);
 }
 
 }  // namespace net