SpdySession: Combine three frames into a single packet.

net/spdy/chromium/spdy_network_transaction_unittest.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 <cmath>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 5602 matching lines @@
   // Size of each DATA frame.
   const int32_t kChunkSize = 4096;
   // Size of window updates.
   ASSERT_EQ(0, session_max_recv_window_size / 2 % kChunkSize);
   const int32_t session_window_update_delta =
       session_max_recv_window_size / 2 + kChunkSize;
   ASSERT_EQ(0, stream_max_recv_window_size / 2 % kChunkSize);
   const int32_t stream_window_update_delta =
       stream_max_recv_window_size / 2 + kChunkSize;
 
+  SpdySerializedFrame preface(const_cast<char*>(kHttp2ConnectionHeaderPrefix),
+                              kHttp2ConnectionHeaderPrefixSize,
+                              /* owns_buffer = */ false);
+
   SettingsMap initial_settings;
   initial_settings[SETTINGS_HEADER_TABLE_SIZE] = kSpdyMaxHeaderTableSize;
   initial_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       kSpdyMaxConcurrentPushedStreams;
   initial_settings[SETTINGS_INITIAL_WINDOW_SIZE] = stream_max_recv_window_size;
   SpdySerializedFrame initial_settings_frame(
       spdy_util_.ConstructSpdySettings(initial_settings));
+
   SpdySerializedFrame initial_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(
           kSessionFlowControlStreamId,
           session_max_recv_window_size - kDefaultInitialWindowSize));
+
+  const SpdySerializedFrame* frames[3] = {&preface, &initial_settings_frame,
+                                          &initial_window_update};
+  char combined_frames[100];
+  int combined_frames_len = CombineFrames(
+      frames, arraysize(frames), combined_frames, arraysize(combined_frames));
+
+  std::vector<MockWrite> writes;
+  writes.push_back(MockWrite(ASYNC, combined_frames, combined_frames_len));
+
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame session_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(0, session_window_update_delta));
-  SpdySerializedFrame stream_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(1, stream_window_update_delta));
-
-  std::vector<MockWrite> writes;
-  writes.push_back(MockWrite(ASYNC, kHttp2ConnectionHeaderPrefix,
-                             kHttp2ConnectionHeaderPrefixSize, 0));
-  writes.push_back(CreateMockWrite(initial_settings_frame, writes.size()));
-  writes.push_back(CreateMockWrite(initial_window_update, writes.size()));
   writes.push_back(CreateMockWrite(req, writes.size()));
 
   std::vector<MockRead> reads;
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   reads.push_back(CreateMockRead(resp, writes.size() + reads.size()));
 
   std::vector<SpdySerializedFrame> body_frames;
   const SpdyString body_data(kChunkSize, 'x');
   for (size_t remaining = kTargetSize; remaining != 0;) {
     size_t frame_size = std::min(remaining, body_data.size());
     body_frames.push_back(spdy_util_.ConstructSpdyDataFrame(1, body_data.data(),
                                                             frame_size, false));
     reads.push_back(
         CreateMockRead(body_frames.back(), writes.size() + reads.size()));
     remaining -= frame_size;
   }
   // Yield.
   reads.push_back(
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, writes.size() + reads.size()));
 
+  SpdySerializedFrame session_window_update(
+      spdy_util_.ConstructSpdyWindowUpdate(0, session_window_update_delta));
   writes.push_back(
       CreateMockWrite(session_window_update, writes.size() + reads.size()));
+  SpdySerializedFrame stream_window_update(
+      spdy_util_.ConstructSpdyWindowUpdate(1, stream_window_update_delta));
   writes.push_back(
       CreateMockWrite(stream_window_update, writes.size() + reads.size()));
 
   SequencedSocketData data(reads.data(), reads.size(), writes.data(),
                            writes.size());
 
   auto session_deps = base::MakeUnique<SpdySessionDependencies>();
   session_deps->session_max_recv_window_size = session_max_recv_window_size;
   session_deps->http2_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       stream_max_recv_window_size;
@@ skipping 950 matching lines @@
 
 TEST_F(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   auto ssl_provider = base::MakeUnique<SSLSocketDataProvider>(ASYNC, OK);
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net