blob: 5f5e01742edca7fb55fc27b7772c64b905f93835 [file] [log] [blame]
// 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/spdy/spdy_test_util_spdy2.h"
#include <string>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/string_number_conversions.h"
#include "base/string_util.h"
#include "net/base/mock_cert_verifier.h"
#include "net/http/http_network_session.h"
#include "net/http/http_network_transaction.h"
#include "net/http/http_server_properties_impl.h"
#include "net/spdy/buffered_spdy_framer.h"
#include "net/spdy/spdy_http_utils.h"
#include "net/spdy/spdy_session.h"
namespace net {
namespace test_spdy2 {
namespace {
// Parses a URL into the scheme, host, and path components required for a
// SPDY request.
void ParseUrl(const char* const url, std::string* scheme, std::string* host,
std::string* path) {
GURL gurl(url);
path->assign(gurl.PathForRequest());
scheme->assign(gurl.scheme());
host->assign(gurl.host());
if (gurl.has_port()) {
host->append(":");
host->append(gurl.port());
}
}
} // namespace
// Chop a frame into an array of MockWrites.
// |data| is the frame to chop.
// |length| is the length of the frame to chop.
// |num_chunks| is the number of chunks to create.
MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks) {
MockWrite* chunks = new MockWrite[num_chunks];
int chunk_size = length / num_chunks;
for (int index = 0; index < num_chunks; index++) {
const char* ptr = data + (index * chunk_size);
if (index == num_chunks - 1)
chunk_size += length % chunk_size; // The last chunk takes the remainder.
chunks[index] = MockWrite(ASYNC, ptr, chunk_size);
}
return chunks;
}
// Chop a SpdyFrame into an array of MockWrites.
// |frame| is the frame to chop.
// |num_chunks| is the number of chunks to create.
MockWrite* ChopWriteFrame(const SpdyFrame& frame, int num_chunks) {
return ChopWriteFrame(frame.data(),
frame.length() + SpdyFrame::kHeaderSize,
num_chunks);
}
// Chop a frame into an array of MockReads.
// |data| is the frame to chop.
// |length| is the length of the frame to chop.
// |num_chunks| is the number of chunks to create.
MockRead* ChopReadFrame(const char* data, int length, int num_chunks) {
MockRead* chunks = new MockRead[num_chunks];
int chunk_size = length / num_chunks;
for (int index = 0; index < num_chunks; index++) {
const char* ptr = data + (index * chunk_size);
if (index == num_chunks - 1)
chunk_size += length % chunk_size; // The last chunk takes the remainder.
chunks[index] = MockRead(ASYNC, ptr, chunk_size);
}
return chunks;
}
// Chop a SpdyFrame into an array of MockReads.
// |frame| is the frame to chop.
// |num_chunks| is the number of chunks to create.
MockRead* ChopReadFrame(const SpdyFrame& frame, int num_chunks) {
return ChopReadFrame(frame.data(),
frame.length() + SpdyFrame::kHeaderSize,
num_chunks);
}
// Adds headers and values to a map.
// |extra_headers| is an array of { name, value } pairs, arranged as strings
// where the even entries are the header names, and the odd entries are the
// header values.
// |headers| gets filled in from |extra_headers|.
void AppendHeadersToSpdyFrame(const char* const extra_headers[],
int extra_header_count,
SpdyHeaderBlock* headers) {
std::string this_header;
std::string this_value;
if (!extra_header_count)
return;
// Sanity check: Non-NULL header list.
DCHECK(NULL != extra_headers) << "NULL header value pair list";
// Sanity check: Non-NULL header map.
DCHECK(NULL != headers) << "NULL header map";
// Copy in the headers.
for (int i = 0; i < extra_header_count; i++) {
// Sanity check: Non-empty header.
DCHECK_NE('\0', *extra_headers[i * 2]) << "Empty header value pair";
this_header = extra_headers[i * 2];
std::string::size_type header_len = this_header.length();
if (!header_len)
continue;
this_value = extra_headers[1 + (i * 2)];
std::string new_value;
if (headers->find(this_header) != headers->end()) {
// More than one entry in the header.
// Don't add the header again, just the append to the value,
// separated by a NULL character.
// Adjust the value.
new_value = (*headers)[this_header];
// Put in a NULL separator.
new_value.append(1, '\0');
// Append the new value.
new_value += this_value;
} else {
// Not a duplicate, just write the value.
new_value = this_value;
}
(*headers)[this_header] = new_value;
}
}
// Writes |val| to a location of size |len|, in big-endian format.
// in the buffer pointed to by |buffer_handle|.
// Updates the |*buffer_handle| pointer by |len|
// Returns the number of bytes written
int AppendToBuffer(int val,
int len,
unsigned char** buffer_handle,
int* buffer_len_remaining) {
if (len <= 0)
return 0;
DCHECK((size_t) len <= sizeof(len)) << "Data length too long for data type";
DCHECK(NULL != buffer_handle) << "NULL buffer handle";
DCHECK(NULL != *buffer_handle) << "NULL pointer";
DCHECK(NULL != buffer_len_remaining)
<< "NULL buffer remainder length pointer";
DCHECK_GE(*buffer_len_remaining, len) << "Insufficient buffer size";
for (int i = 0; i < len; i++) {
int shift = (8 * (len - (i + 1)));
unsigned char val_chunk = (val >> shift) & 0x0FF;
*(*buffer_handle)++ = val_chunk;
*buffer_len_remaining += 1;
}
return len;
}
// Construct a SPDY packet.
// |head| is the start of the packet, up to but not including
// the header value pairs.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// |tail| is any (relatively constant) header-value pairs to add.
// |buffer| is the buffer we're filling in.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyPacket(const SpdyHeaderInfo& header_info,
const char* const extra_headers[],
int extra_header_count,
const char* const tail[],
int tail_header_count) {
BufferedSpdyFramer framer(2, header_info.compressed);
SpdyHeaderBlock headers;
// Copy in the extra headers to our map.
AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
// Copy in the tail headers to our map.
if (tail && tail_header_count)
AppendHeadersToSpdyFrame(tail, tail_header_count, &headers);
SpdyFrame* frame = NULL;
switch (header_info.kind) {
case SYN_STREAM:
frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
header_info.priority, 0,
header_info.control_flags,
header_info.compressed, &headers);
break;
case SYN_REPLY:
frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
header_info.compressed, &headers);
break;
case RST_STREAM:
frame = framer.CreateRstStream(header_info.id, header_info.status);
break;
case HEADERS:
frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
header_info.compressed, &headers);
break;
default:
frame = framer.CreateDataFrame(header_info.id, header_info.data,
header_info.data_length,
header_info.data_flags);
break;
}
return frame;
}
// Construct an expected SPDY SETTINGS frame.
// |settings| are the settings to set.
// Returns the constructed frame. The caller takes ownership of the frame.
SpdyFrame* ConstructSpdySettings(const SettingsMap& settings) {
BufferedSpdyFramer framer(2, false);
return framer.CreateSettings(settings);
}
// Construct an expected SPDY CREDENTIAL frame.
// |credential| is the credential to sen.
// Returns the constructed frame. The caller takes ownership of the frame.
SpdyFrame* ConstructSpdyCredential(
const SpdyCredential& credential) {
BufferedSpdyFramer framer(2, false);
return framer.CreateCredentialFrame(credential);
}
// Construct a SPDY PING frame.
// Returns the constructed frame. The caller takes ownership of the frame.
SpdyFrame* ConstructSpdyPing(uint32 ping_id) {
BufferedSpdyFramer framer(2, false);
return framer.CreatePingFrame(ping_id);
}
// Construct a SPDY GOAWAY frame.
// Returns the constructed frame. The caller takes ownership of the frame.
SpdyFrame* ConstructSpdyGoAway() {
BufferedSpdyFramer framer(2, false);
return framer.CreateGoAway(0, GOAWAY_OK);
}
// Construct a SPDY WINDOW_UPDATE frame.
// Returns the constructed frame. The caller takes ownership of the frame.
SpdyFrame* ConstructSpdyWindowUpdate(
const SpdyStreamId stream_id, uint32 delta_window_size) {
BufferedSpdyFramer framer(2, false);
return framer.CreateWindowUpdate(stream_id, delta_window_size);
}
// Construct a SPDY RST_STREAM frame.
// Returns the constructed frame. The caller takes ownership of the frame.
SpdyFrame* ConstructSpdyRstStream(SpdyStreamId stream_id,
SpdyStatusCodes status) {
BufferedSpdyFramer framer(2, false);
return framer.CreateRstStream(stream_id, status);
}
// Construct a single SPDY header entry, for validation.
// |extra_headers| are the extra header-value pairs.
// |buffer| is the buffer we're filling in.
// |index| is the index of the header we want.
// Returns the number of bytes written into |buffer|.
int ConstructSpdyHeader(const char* const extra_headers[],
int extra_header_count,
char* buffer,
int buffer_length,
int index) {
const char* this_header = NULL;
const char* this_value = NULL;
if (!buffer || !buffer_length)
return 0;
*buffer = '\0';
// Sanity check: Non-empty header list.
DCHECK(NULL != extra_headers) << "NULL extra headers pointer";
// Sanity check: Index out of range.
DCHECK((index >= 0) && (index < extra_header_count))
<< "Index " << index
<< " out of range [0, " << extra_header_count << ")";
this_header = extra_headers[index * 2];
// Sanity check: Non-empty header.
if (!*this_header)
return 0;
std::string::size_type header_len = strlen(this_header);
if (!header_len)
return 0;
this_value = extra_headers[1 + (index * 2)];
// Sanity check: Non-empty value.
if (!*this_value)
this_value = "";
int n = base::snprintf(buffer,
buffer_length,
"%s: %s\r\n",
this_header,
this_value);
return n;
}
SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
int extra_header_count,
bool compressed,
int stream_id,
RequestPriority request_priority,
SpdyControlType type,
SpdyControlFlags flags,
const char* const* kHeaders,
int kHeadersSize) {
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
compressed,
stream_id,
request_priority,
type,
flags,
kHeaders,
kHeadersSize,
0);
}
SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
int extra_header_count,
bool compressed,
int stream_id,
RequestPriority request_priority,
SpdyControlType type,
SpdyControlFlags flags,
const char* const* kHeaders,
int kHeadersSize,
int associated_stream_id) {
const SpdyHeaderInfo kSynStartHeader = {
type, // Kind = Syn
stream_id, // Stream ID
associated_stream_id, // Associated stream ID
ConvertRequestPriorityToSpdyPriority(request_priority, 2),
// Priority
flags, // Control Flags
compressed, // Compressed
INVALID, // Status
NULL, // Data
0, // Length
DATA_FLAG_NONE // Data Flags
};
return ConstructSpdyPacket(kSynStartHeader,
extra_headers,
extra_header_count,
kHeaders,
kHeadersSize / 2);
}
// Constructs a standard SPDY GET SYN packet, optionally compressed
// for the url |url|.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyGet(const char* const url,
bool compressed,
int stream_id,
RequestPriority request_priority) {
const SpdyHeaderInfo kSynStartHeader = {
SYN_STREAM, // Kind = Syn
stream_id, // Stream ID
0, // Associated stream ID
ConvertRequestPriorityToSpdyPriority(request_priority, 2),
// Priority
CONTROL_FLAG_FIN, // Control Flags
compressed, // Compressed
INVALID, // Status
NULL, // Data
0, // Length
DATA_FLAG_NONE // Data Flags
};
std::string scheme, host, path;
ParseUrl(url, &scheme, &host, &path);
const char* const headers[] = {
"method", "GET",
"url", path.c_str(),
"host", host.c_str(),
"scheme", scheme.c_str(),
"version", "HTTP/1.1"
};
return ConstructSpdyPacket(
kSynStartHeader,
NULL,
0,
headers,
arraysize(headers) / 2);
}
// Constructs a standard SPDY GET SYN packet, optionally compressed.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
int extra_header_count,
bool compressed,
int stream_id,
RequestPriority request_priority) {
return ConstructSpdyGet(extra_headers, extra_header_count, compressed,
stream_id, request_priority, true);
}
// Constructs a standard SPDY GET SYN packet, optionally compressed.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
int extra_header_count,
bool compressed,
int stream_id,
RequestPriority request_priority,
bool direct) {
const char* const kStandardGetHeaders[] = {
"method", "GET",
"url", (direct ? "/" : "http://www.google.com/"),
"host", "www.google.com",
"scheme", "http",
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
compressed,
stream_id,
request_priority,
SYN_STREAM,
CONTROL_FLAG_FIN,
kStandardGetHeaders,
arraysize(kStandardGetHeaders));
}
// Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
SpdyFrame* ConstructSpdyConnect(const char* const extra_headers[],
int extra_header_count,
int stream_id) {
const char* const kConnectHeaders[] = {
"method", "CONNECT",
"url", "www.google.com:443",
"host", "www.google.com",
"version", "HTTP/1.1",
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
/*compressed*/ false,
stream_id,
LOWEST,
SYN_STREAM,
CONTROL_FLAG_NONE,
kConnectHeaders,
arraysize(kConnectHeaders));
}
// Constructs a standard SPDY push SYN packet.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
int extra_header_count,
int stream_id,
int associated_stream_id) {
const char* const kStandardGetHeaders[] = {
"hello", "bye",
"status", "200",
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
stream_id,
LOWEST,
SYN_STREAM,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders),
associated_stream_id);
}
SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
int extra_header_count,
int stream_id,
int associated_stream_id,
const char* url) {
const char* const kStandardGetHeaders[] = {
"hello", "bye",
"status", "200 OK",
"url", url,
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
stream_id,
LOWEST,
SYN_STREAM,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders),
associated_stream_id);
}
SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
int extra_header_count,
int stream_id,
int associated_stream_id,
const char* url,
const char* status,
const char* location) {
const char* const kStandardGetHeaders[] = {
"hello", "bye",
"status", status,
"location", location,
"url", url,
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
stream_id,
LOWEST,
SYN_STREAM,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders),
associated_stream_id);
}
SpdyFrame* ConstructSpdyPush(int stream_id,
int associated_stream_id,
const char* url) {
const char* const kStandardGetHeaders[] = {
"url", url
};
return ConstructSpdyControlFrame(0,
0,
false,
stream_id,
LOWEST,
SYN_STREAM,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders),
associated_stream_id);
}
SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
const char* const extra_headers[],
int extra_header_count) {
const char* const kStandardGetHeaders[] = {
"status", "200 OK",
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
stream_id,
LOWEST,
HEADERS,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders));
}
// Constructs a standard SPDY SYN_REPLY packet with the specified status code.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdySynReplyError(const char* const status,
const char* const* const extra_headers,
int extra_header_count,
int stream_id) {
const char* const kStandardGetHeaders[] = {
"hello", "bye",
"status", status,
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
stream_id,
LOWEST,
SYN_REPLY,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders));
}
// Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id) {
static const char* const kExtraHeaders[] = {
"location", "http://www.foo.com/index.php",
};
return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
arraysize(kExtraHeaders)/2, stream_id);
}
// Constructs a standard SPDY SYN_REPLY packet with an Internal Server
// Error status code.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdySynReplyError(int stream_id) {
return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
}
// Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
int extra_header_count,
int stream_id) {
static const char* const kStandardGetHeaders[] = {
"hello", "bye",
"status", "200",
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
stream_id,
LOWEST,
SYN_REPLY,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders));
}
// Constructs a standard SPDY POST SYN packet.
// |content_length| is the size of post data.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyPost(int64 content_length,
const char* const extra_headers[],
int extra_header_count) {
std::string length_str = base::Int64ToString(content_length);
const char* post_headers[] = {
"method", "POST",
"url", "/",
"host", "www.google.com",
"scheme", "http",
"version", "HTTP/1.1",
"content-length", length_str.c_str()
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
1,
LOWEST,
SYN_STREAM,
CONTROL_FLAG_NONE,
post_headers,
arraysize(post_headers));
}
// Constructs a chunked transfer SPDY POST SYN packet.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
int extra_header_count) {
const char* post_headers[] = {
"method", "POST",
"url", "/",
"host", "www.google.com",
"scheme", "http",
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
1,
LOWEST,
SYN_STREAM,
CONTROL_FLAG_NONE,
post_headers,
arraysize(post_headers));
}
// Constructs a standard SPDY SYN_REPLY packet to match the SPDY POST.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// Returns a SpdyFrame.
SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
int extra_header_count) {
static const char* const kStandardGetHeaders[] = {
"hello", "bye",
"status", "200",
"url", "/index.php",
"version", "HTTP/1.1"
};
return ConstructSpdyControlFrame(extra_headers,
extra_header_count,
false,
1,
LOWEST,
SYN_REPLY,
CONTROL_FLAG_NONE,
kStandardGetHeaders,
arraysize(kStandardGetHeaders));
}
// Constructs a single SPDY data frame with the default contents.
SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin) {
BufferedSpdyFramer framer(2, false);
return framer.CreateDataFrame(
stream_id, kUploadData, kUploadDataSize,
fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
}
// Constructs a single SPDY data frame with the given content.
SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
uint32 len, bool fin) {
BufferedSpdyFramer framer(2, false);
return framer.CreateDataFrame(
stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
}
// Wraps |frame| in the payload of a data frame in stream |stream_id|.
SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
int stream_id) {
return ConstructSpdyBodyFrame(stream_id, frame->data(),
frame->length() + SpdyFrame::kHeaderSize,
false);
}
// Construct an expected SPDY reply string.
// |extra_headers| are the extra header-value pairs, which typically
// will vary the most between calls.
// |buffer| is the buffer we're filling in.
// Returns the number of bytes written into |buffer|.
int ConstructSpdyReplyString(const char* const extra_headers[],
int extra_header_count,
char* buffer,
int buffer_length) {
int packet_size = 0;
char* buffer_write = buffer;
int buffer_left = buffer_length;
SpdyHeaderBlock headers;
if (!buffer || !buffer_length)
return 0;
// Copy in the extra headers.
AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
// The iterator gets us the list of header/value pairs in sorted order.
SpdyHeaderBlock::iterator next = headers.begin();
SpdyHeaderBlock::iterator last = headers.end();
for ( ; next != last; ++next) {
// Write the header.
int value_len, current_len, offset;
const char* header_string = next->first.c_str();
packet_size += AppendToBuffer(header_string,
next->first.length(),
&buffer_write,
&buffer_left);
packet_size += AppendToBuffer(": ",
strlen(": "),
&buffer_write,
&buffer_left);
// Write the value(s).
const char* value_string = next->second.c_str();
// Check if it's split among two or more values.
value_len = next->second.length();
current_len = strlen(value_string);
offset = 0;
// Handle the first N-1 values.
while (current_len < value_len) {
// Finish this line -- write the current value.
packet_size += AppendToBuffer(value_string + offset,
current_len - offset,
&buffer_write,
&buffer_left);
packet_size += AppendToBuffer("\n",
strlen("\n"),
&buffer_write,
&buffer_left);
// Advance to next value.
offset = current_len + 1;
current_len += 1 + strlen(value_string + offset);
// Start another line -- add the header again.
packet_size += AppendToBuffer(header_string,
next->first.length(),
&buffer_write,
&buffer_left);
packet_size += AppendToBuffer(": ",
strlen(": "),
&buffer_write,
&buffer_left);
}
EXPECT_EQ(value_len, current_len);
// Copy the last (or only) value.
packet_size += AppendToBuffer(value_string + offset,
value_len - offset,
&buffer_write,
&buffer_left);
packet_size += AppendToBuffer("\n",
strlen("\n"),
&buffer_write,
&buffer_left);
}
return packet_size;
}
// Create a MockWrite from the given SpdyFrame.
MockWrite CreateMockWrite(const SpdyFrame& req) {
return MockWrite(
ASYNC, req.data(), req.length() + SpdyFrame::kHeaderSize);
}
// Create a MockWrite from the given SpdyFrame and sequence number.
MockWrite CreateMockWrite(const SpdyFrame& req, int seq) {
return CreateMockWrite(req, seq, ASYNC);
}
// Create a MockWrite from the given SpdyFrame and sequence number.
MockWrite CreateMockWrite(const SpdyFrame& req, int seq, IoMode mode) {
return MockWrite(
mode, req.data(), req.length() + SpdyFrame::kHeaderSize, seq);
}
// Create a MockRead from the given SpdyFrame.
MockRead CreateMockRead(const SpdyFrame& resp) {
return MockRead(
ASYNC, resp.data(), resp.length() + SpdyFrame::kHeaderSize);
}
// Create a MockRead from the given SpdyFrame and sequence number.
MockRead CreateMockRead(const SpdyFrame& resp, int seq) {
return CreateMockRead(resp, seq, ASYNC);
}
// Create a MockRead from the given SpdyFrame and sequence number.
MockRead CreateMockRead(const SpdyFrame& resp, int seq, IoMode mode) {
return MockRead(
mode, resp.data(), resp.length() + SpdyFrame::kHeaderSize, seq);
}
// Combines the given SpdyFrames into the given char array and returns
// the total length.
int CombineFrames(const SpdyFrame** frames, int num_frames,
char* buff, int buff_len) {
int total_len = 0;
for (int i = 0; i < num_frames; ++i) {
total_len += frames[i]->length() + SpdyFrame::kHeaderSize;
}
DCHECK_LE(total_len, buff_len);
char* ptr = buff;
for (int i = 0; i < num_frames; ++i) {
int len = frames[i]->length() + SpdyFrame::kHeaderSize;
memcpy(ptr, frames[i]->data(), len);
ptr += len;
}
return total_len;
}
SpdySessionDependencies::SpdySessionDependencies()
: host_resolver(new MockCachingHostResolver),
cert_verifier(new MockCertVerifier),
proxy_service(ProxyService::CreateDirect()),
ssl_config_service(new SSLConfigServiceDefaults),
socket_factory(new MockClientSocketFactory),
deterministic_socket_factory(new DeterministicMockClientSocketFactory),
http_auth_handler_factory(
HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
enable_ip_pooling(true),
enable_compression(false),
enable_ping(false),
time_func(&base::TimeTicks::Now),
net_log(NULL) {
// Note: The CancelledTransaction test does cleanup by running all
// tasks in the message loop (RunAllPending). Unfortunately, that
// doesn't clean up tasks on the host resolver thread; and
// TCPConnectJob is currently not cancellable. Using synchronous
// lookups allows the test to shutdown cleanly. Until we have
// cancellable TCPConnectJobs, use synchronous lookups.
host_resolver->set_synchronous_mode(true);
}
SpdySessionDependencies::SpdySessionDependencies(ProxyService* proxy_service)
: host_resolver(new MockHostResolver),
cert_verifier(new MockCertVerifier),
proxy_service(proxy_service),
ssl_config_service(new SSLConfigServiceDefaults),
socket_factory(new MockClientSocketFactory),
deterministic_socket_factory(new DeterministicMockClientSocketFactory),
http_auth_handler_factory(
HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
enable_ip_pooling(true),
enable_compression(false),
enable_ping(false),
time_func(&base::TimeTicks::Now),
net_log(NULL) {}
SpdySessionDependencies::~SpdySessionDependencies() {}
// static
HttpNetworkSession* SpdySessionDependencies::SpdyCreateSession(
SpdySessionDependencies* session_deps) {
net::HttpNetworkSession::Params params = CreateSessionParams(session_deps);
params.client_socket_factory = session_deps->socket_factory.get();
HttpNetworkSession* http_session = new HttpNetworkSession(params);
SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
pool_peer.EnableSendingInitialSettings(false);
return http_session;
}
// static
HttpNetworkSession* SpdySessionDependencies::SpdyCreateSessionDeterministic(
SpdySessionDependencies* session_deps) {
net::HttpNetworkSession::Params params = CreateSessionParams(session_deps);
params.client_socket_factory =
session_deps->deterministic_socket_factory.get();
HttpNetworkSession* http_session = new HttpNetworkSession(params);
SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
pool_peer.EnableSendingInitialSettings(false);
return http_session;
}
// static
net::HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
SpdySessionDependencies* session_deps) {
net::HttpNetworkSession::Params params;
params.host_resolver = session_deps->host_resolver.get();
params.cert_verifier = session_deps->cert_verifier.get();
params.proxy_service = session_deps->proxy_service.get();
params.ssl_config_service = session_deps->ssl_config_service;
params.http_auth_handler_factory =
session_deps->http_auth_handler_factory.get();
params.http_server_properties = &session_deps->http_server_properties;
params.enable_spdy_ip_pooling = session_deps->enable_ip_pooling;
params.enable_spdy_compression = session_deps->enable_compression;
params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
params.spdy_default_protocol = kProtoSPDY2;
params.time_func = session_deps->time_func;
params.trusted_spdy_proxy = session_deps->trusted_spdy_proxy;
params.net_log = session_deps->net_log;
return params;
}
SpdyURLRequestContext::SpdyURLRequestContext()
: ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) {
storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver));
storage_.set_cert_verifier(new MockCertVerifier);
storage_.set_proxy_service(ProxyService::CreateDirect());
storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
storage_.set_http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault(
host_resolver()));
storage_.set_http_server_properties(new HttpServerPropertiesImpl);
net::HttpNetworkSession::Params params;
params.client_socket_factory = &socket_factory_;
params.host_resolver = host_resolver();
params.cert_verifier = cert_verifier();
params.proxy_service = proxy_service();
params.ssl_config_service = ssl_config_service();
params.http_auth_handler_factory = http_auth_handler_factory();
params.network_delegate = network_delegate();
params.enable_spdy_compression = false;
params.enable_spdy_ping_based_connection_checking = false;
params.spdy_default_protocol = kProtoSPDY2;
params.http_server_properties = http_server_properties();
scoped_refptr<HttpNetworkSession> network_session(
new HttpNetworkSession(params));
SpdySessionPoolPeer pool_peer(network_session->spdy_session_pool());
pool_peer.EnableSendingInitialSettings(false);
storage_.set_http_transaction_factory(new HttpCache(
network_session,
HttpCache::DefaultBackend::InMemory(0)));
}
SpdyURLRequestContext::~SpdyURLRequestContext() {
}
const SpdyHeaderInfo MakeSpdyHeader(SpdyControlType type) {
const SpdyHeaderInfo kHeader = {
type, // Kind = Syn
1, // Stream ID
0, // Associated stream ID
ConvertRequestPriorityToSpdyPriority(LOWEST, 2), // Priority
CONTROL_FLAG_FIN, // Control Flags
false, // Compressed
INVALID, // Status
NULL, // Data
0, // Length
DATA_FLAG_NONE // Data Flags
};
return kHeader;
}
} // namespace test_spdy2
} // namespace net