Implement SpdySerializedFrame move semantics.

net/spdy/spdy_protocol.h

 // 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.
 
 // This file contains some protocol structures for use with SPDY 3 and HTTP 2
 // The SPDY 3 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
 
 #ifndef NET_SPDY_SPDY_PROTOCOL_H_
 #define NET_SPDY_SPDY_PROTOCOL_H_
@@ skipping 504 matching lines @@
 
   // Initial window size for a stream in bytes.
   static int32_t GetInitialStreamWindowSize(SpdyMajorVersion version);
 
   // Initial window size for a session in bytes.
   static int32_t GetInitialSessionWindowSize(SpdyMajorVersion version);
 
   static std::string GetVersionString(SpdyMajorVersion version);
 };
 
-class SpdyFrame;
-typedef SpdyFrame SpdySerializedFrame;
-
 class SpdyFrameVisitor;
 
 // Intermediate representation for SPDY frames.
-// TODO(hkhalil): Rename this class to SpdyFrame when the existing SpdyFrame is
-// gone.
 class NET_EXPORT_PRIVATE SpdyFrameIR {
  public:
   virtual ~SpdyFrameIR() {}
 
   virtual void Visit(SpdyFrameVisitor* visitor) const = 0;
 
  protected:
   SpdyFrameIR() {}
 
  private:
@@ skipping 437 matching lines @@
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId parent_stream_id_;
   uint8_t weight_;
   bool exclusive_;
   DISALLOW_COPY_AND_ASSIGN(SpdyPriorityIR);
 };
 
-// -------------------------------------------------------------------------
-// Wrapper classes for various SPDY frames.
+class SpdySerializedFrame {
+ public:
+  SpdySerializedFrame()
+      : frame_(const_cast<char*>("")), size_(0), owns_buffer_(false) {}
 
-// All Spdy Frame types derive from this SpdyFrame class.
-class SpdyFrame {
- public:
-  // Create a SpdyFrame using a pre-created buffer.
-  // If |owns_buffer| is true, this class takes ownership of the buffer
-  // and will delete it on cleanup.  The buffer must have been created using
-  // new char[].
+  // Create a valid SpdySerializedFrame using a pre-created buffer.
+  // If |owns_buffer| is true, this class takes ownership of the buffer and will
+  // delete it on cleanup.  The buffer must have been created using new char[].
   // If |owns_buffer| is false, the caller retains ownership of the buffer and
   // is responsible for making sure the buffer outlives this frame.  In other
   // words, this class does NOT create a copy of the buffer.
-  SpdyFrame(char* data, size_t size, bool owns_buffer)
-      : frame_(data),
-        size_(size),
-        owns_buffer_(owns_buffer) {
-    DCHECK(frame_);
+  SpdySerializedFrame(char* data, size_t size, bool owns_buffer)
+      : frame_(data), size_(size), owns_buffer_(owns_buffer) {}
+
+  SpdySerializedFrame(SpdySerializedFrame&& other)
+      : frame_(other.frame_),
+        size_(other.size_),
+        owns_buffer_(other.owns_buffer_) {
+    // |other| is no longer responsible for the buffer.
+    other.owns_buffer_ = false;
   }
 
-  ~SpdyFrame() {
+  SpdySerializedFrame& operator=(SpdySerializedFrame&& other) {
+    // Free buffer if necessary.
     if (owns_buffer_) {
-      delete [] frame_;
+      delete[] frame_;
     }
-    frame_ = NULL;
+    // Take over |other|.
+    frame_ = other.frame_;
+    size_ = other.size_;
+    owns_buffer_ = other.owns_buffer_;
+    // |other| is no longer responsible for the buffer.
+    other.owns_buffer_ = false;
+    return *this;
   }
 
-  // Provides access to the frame bytes, which is a buffer containing
-  // the frame packed as expected for sending over the wire.
+  ~SpdySerializedFrame() {
+    if (owns_buffer_) {
+      delete[] frame_;
+    }
+  }
+
+  // Provides access to the frame bytes, which is a buffer containing the frame
+  // packed as expected for sending over the wire.
   char* data() const { return frame_; }
 
   // Returns the actual size of the underlying buffer.
   size_t size() const { return size_; }
 
  protected:
   char* frame_;
 
  private:
   size_t size_;
   bool owns_buffer_;
-  DISALLOW_COPY_AND_ASSIGN(SpdyFrame);
+  DISALLOW_COPY_AND_ASSIGN(SpdySerializedFrame);
 };
 
 // This interface is for classes that want to process SpdyFrameIRs without
 // having to know what type they are.  An instance of this interface can be
 // passed to a SpdyFrameIR's Visit method, and the appropriate type-specific
 // method of this class will be called.
 class SpdyFrameVisitor {
  public:
   virtual void VisitSynStream(const SpdySynStreamIR& syn_stream) = 0;
   virtual void VisitSynReply(const SpdySynReplyIR& syn_reply) = 0;
@@ skipping 14 matching lines @@
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_