Implement SpdySerializedFrame move semantics.

net/tools/flip_server/spdy_interface.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/tools/flip_server/spdy_interface.h"
 
 #include <algorithm>
 #include <string>
 
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/tools/flip_server/constants.h"
 #include "net/tools/flip_server/flip_config.h"
 #include "net/tools/flip_server/http_interface.h"
 #include "net/tools/flip_server/spdy_util.h"
 #include "net/tools/flip_server/url_utilities.h"
 
 namespace net {
 
 // static
 std::string SpdySM::forward_ip_header_;
 
 class SpdyFrameDataFrame : public DataFrame {
  public:
-  explicit SpdyFrameDataFrame(SpdyFrame* spdy_frame) : frame(spdy_frame) {
+  explicit SpdyFrameDataFrame(SpdySerializedFrame* spdy_frame)
+      : frame(spdy_frame) {
     data = spdy_frame->data();
     size = spdy_frame->size();
   }
 
   ~SpdyFrameDataFrame() override { delete frame; }
 
-  const SpdyFrame* frame;
+  const SpdySerializedFrame* frame;
 };
 
 SpdySM::SpdySM(SMConnection* connection,
                SMInterface* sm_http_interface,
                EpollServer* epoll_server,
                MemoryCache* memory_cache,
                FlipAcceptor* acceptor,
                SpdyMajorVersion spdy_version)
     : buffered_spdy_framer_(new BufferedSpdyFramer(spdy_version)),
       valid_spdy_session_(false),
@@ skipping 294 matching lines @@
   next_outgoing_stream_id_ = 2;
 }
 
 // Send a settings frame
 int SpdySM::PostAcceptHook() {
   // We should have buffered_spdy_framer_ set after reuse
   DCHECK(buffered_spdy_framer_);
   SettingsMap settings;
   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 100);
-  SpdyFrame* settings_frame = buffered_spdy_framer_->CreateSettings(settings);
+  SpdySerializedFrame* settings_frame =
+      buffered_spdy_framer_->CreateSettings(settings);
 
   VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Sending Settings Frame";
   EnqueueDataFrame(new SpdyFrameDataFrame(settings_frame));
   return 1;
 }
 
 void SpdySM::NewStream(uint32_t stream_id,
                        uint32_t priority,
                        const std::string& filename) {
   MemCacheIter mci;
@@ skipping 102 matching lines @@
     block[":host"] = UrlUtilities::GetUrlPath(original_url);
   } else {
     block[":path"] = headers.request_uri().as_string();
     if (block.find("host") != block.end()) {
       block[":host"] = headers.GetHeader("Host").as_string();
       block.erase("host");
     }
   }
 
   DCHECK(buffered_spdy_framer_);
-  SpdyFrame* fsrcf = buffered_spdy_framer_->CreateSynStream(
+  SpdySerializedFrame* fsrcf = buffered_spdy_framer_->CreateSynStream(
       stream_id, 0, 0, CONTROL_FLAG_NONE, &block);
   size_t df_size = fsrcf->size();
   EnqueueDataFrame(new SpdyFrameDataFrame(fsrcf));
 
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynStreamheader "
           << stream_id;
   return df_size;
 }
 
 size_t SpdySM::SendSynReplyImpl(uint32_t stream_id,
                                 const BalsaHeaders& headers) {
   SpdyHeaderBlock block;
   CopyHeaders(block, headers);
   block[":status"] = headers.response_code().as_string() + " " +
                      headers.response_reason_phrase().as_string();
   block[":version"] = headers.response_version().as_string();
 
   DCHECK(buffered_spdy_framer_);
-  SpdyFrame* fsrcf = buffered_spdy_framer_->CreateSynReply(
+  SpdySerializedFrame* fsrcf = buffered_spdy_framer_->CreateSynReply(
       stream_id, CONTROL_FLAG_NONE, &block);
   size_t df_size = fsrcf->size();
   EnqueueDataFrame(new SpdyFrameDataFrame(fsrcf));
 
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynReplyheader "
           << stream_id;
   return df_size;
 }
 
 void SpdySM::SendDataFrameImpl(uint32_t stream_id,
                                const char* data,
                                int64_t len,
                                SpdyDataFlags flags,
                                bool compress) {
   DCHECK(buffered_spdy_framer_);
   // TODO(mbelshe):  We can't compress here - before going into the
   //                 priority queue.  Compression needs to be done
   //                 with late binding.
   if (len == 0) {
-    SpdyFrame* fdf =
+    SpdySerializedFrame* fdf =
         buffered_spdy_framer_->CreateDataFrame(stream_id, data, len, flags);
     EnqueueDataFrame(new SpdyFrameDataFrame(fdf));
     return;
   }
 
   // Chop data frames into chunks so that one stream can't monopolize the
   // output channel.
   while (len > 0) {
     int64_t size = std::min(len, static_cast<int64_t>(kSpdySegmentSize));
     SpdyDataFlags chunk_flags = flags;
 
     // If we chunked this block, and the FIN flag was set, there is more
     // data coming.  So, remove the flag.
     if ((size < len) && (flags & DATA_FLAG_FIN))
       chunk_flags = static_cast<SpdyDataFlags>(chunk_flags & ~DATA_FLAG_FIN);
 
-    SpdyFrame* fdf = buffered_spdy_framer_->CreateDataFrame(
+    SpdySerializedFrame* fdf = buffered_spdy_framer_->CreateDataFrame(
         stream_id, data, size, chunk_flags);
     EnqueueDataFrame(new SpdyFrameDataFrame(fdf));
 
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending data frame "
             << stream_id << " [" << size << "] shrunk to "
             << (fdf->size() - kSpdyOverhead) << ", flags=" << flags;
 
     data += size;
     len -= size;
   }
@@ skipping 65 matching lines @@
   }
 }
 
 void SpdySM::CreateFramer(SpdyMajorVersion spdy_version) {
   DCHECK(!buffered_spdy_framer_);
   buffered_spdy_framer_.reset(new BufferedSpdyFramer(spdy_version));
   buffered_spdy_framer_->set_visitor(this);
 }
 
 }  // namespace net