Reduce the Spdy data frame sizes used. Attempt to make them fit within SSL...

net/tools/flip_server/flip_in_mem_edsm_server.cc

 // Copyright (c) 2009 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 <dirent.h>
 #include <netinet/tcp.h>  // For TCP_NODELAY
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <openssl/err.h>
@@ skipping 252 matching lines @@
   PrintSslError();
 
   SSL_set_accept_state(ssl);
   PrintSslError();
 
   return ssl;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-const int kMSS = 1460;
-const int kInitialDataSendersThreshold = (2 * kMSS) - SpdyFrame::size();
-const int kNormalSegmentSize = (2 * kMSS) - SpdyFrame::size();
+const int kMSS = 1400;  // Linux default
+const int kSSLOverhead = 33;
+const int kSpdyOverhead = SpdyFrame::size();
+const int kInitialDataSendersThreshold = (2 * kMSS) - kSpdyOverhead;
+const int kSSLSegmentSize = (1 * kMSS) - kSSLOverhead;
+const int kSpdySegmentSize = kSSLSegmentSize - kSpdyOverhead;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class DataFrame {
  public:
   const char* data;
   size_t size;
   bool delete_when_done;
   size_t index;
   DataFrame() : data(NULL), size(0), delete_when_done(false), index(0) {}
@@ skipping 1262 matching lines @@
     while (!priority_map_.empty()) {
       PriorityRing& first_ring = priority_map_.begin()->second;
       if (first_ring.empty()) {
         priority_map_.erase(priority_map_.begin());
         continue;
       }
       MemCacheIter& mci = first_ring.front();
       first_ring.splice(first_ring.end(),
                         first_ring,
                         first_ring.begin());
-      mci.max_segment_size = kNormalSegmentSize;
+      mci.max_segment_size = kSpdySegmentSize;
       return &mci;
     }
     return NULL;
   }
 
   void RemoveStreamId(uint32 stream_id) {
     StreamIdToPriorityMap::iterator sitpmi = stream_ids_.find(stream_id);
     if (sitpmi == stream_ids_.end())
       return;
     PriorityMapPointer& pmp = sitpmi->second;
@@ skipping 495 matching lines @@
 
   void SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
                          SpdyDataFlags flags, bool compress) {
     // Force compression off if disabled via command line.
     if (!FLAGS_use_compression)
       flags = static_cast<SpdyDataFlags>(flags & ~DATA_FLAG_COMPRESSED);
 
     // TODO(mbelshe):  We can't compress here - before going into the
     //                 priority queue.  Compression needs to be done
     //                 with late binding.
-    SpdyDataFrame* fdf = spdy_framer_->CreateDataFrame(stream_id, data, len,
-                                                       flags);
-    DataFrame df;
-    df.size = fdf->length() + SpdyFrame::size();
-    df.data = fdf->data();
-    df.delete_when_done = true;
-    EnqueueDataFrame(df);
 
-    VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending data frame "
-            << stream_id << " [" << len << "] shrunk to " << fdf->length();
+    if (len == 0) {
+      SpdyDataFrame* fdf = spdy_framer_->CreateDataFrame(stream_id, data, len,
+                                                         flags);
+      DataFrame df;
+      df.size = fdf->length() + SpdyFrame::size();
+      df.data = fdf->data();
+      df.delete_when_done = true;
+      EnqueueDataFrame(df);
+      return;
+    }
+
+    // Chop data frames into chunks so that one stream can't monopolize the
+    // output channel.
+    while(len > 0) {
+      int64 size = std::min(len, static_cast<int64>(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);
+
+      SpdyDataFrame* fdf = spdy_framer_->CreateDataFrame(stream_id, data, size,
+                                                         chunk_flags);
+      DataFrame df;
+      df.size = fdf->length() + SpdyFrame::size();
+      df.data = fdf->data();
+      df.delete_when_done = true;
+      EnqueueDataFrame(df);
+
+      VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending data frame "
+              << stream_id << " [" << size << "] shrunk to " << fdf->length()
+              << ", flags=" << flags;
+
+      data += size;
+      len -= size;
+    }
   }
 
   void EnqueueDataFrame(const DataFrame& df) {
     connection_->EnqueueDataFrame(df);
   }
 
   void GetOutput() {
     while (client_output_list_->size() < 2) {
       MemCacheIter* mci = client_output_ordering_.GetIter();
       if (mci == NULL) {
@@ skipping 1075 matching lines @@
       for (unsigned int i = 0; i < sm_worker_threads_.size(); ++i) {
         sm_worker_threads_[i]->Join();
       }
       return 0;
     }
     usleep(1000*10);  // 10 ms
   }
 
   return 0;
 }