spdy_stream_test_util.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/spdy/spdy_stream_test_util.h"
6
7#include <cstddef>
8
9#include "base/stl_util.h"
10#include "net/base/completion_callback.h"
11#include "net/spdy/spdy_stream.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14namespace net {
15
16namespace test {
17
18ClosingDelegate::ClosingDelegate(
19    const scoped_refptr<SpdyStream>& stream) : stream_(stream) {}
20
21ClosingDelegate::~ClosingDelegate() {}
22
23SpdySendStatus ClosingDelegate::OnSendHeadersComplete() {
24  return NO_MORE_DATA_TO_SEND;
25}
26
27int ClosingDelegate::OnSendBody() {
28  return OK;
29}
30
31SpdySendStatus ClosingDelegate::OnSendBodyComplete(size_t /*bytes_sent*/) {
32  return NO_MORE_DATA_TO_SEND;
33}
34
35int ClosingDelegate::OnResponseReceived(const SpdyHeaderBlock& response,
36                                        base::Time response_time,
37                                        int status) {
38  return OK;
39}
40
41void ClosingDelegate::OnHeadersSent() {}
42
43int ClosingDelegate::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
44  return OK;
45}
46
47void ClosingDelegate::OnDataSent(size_t bytes_sent) {}
48
49void ClosingDelegate::OnClose(int status) {
50  if (stream_)
51    stream_->Close();
52  stream_ = NULL;
53}
54
55StreamDelegateBase::StreamDelegateBase(
56    const scoped_refptr<SpdyStream>& stream)
57    : stream_(stream),
58      send_headers_completed_(false),
59      headers_sent_(0),
60      data_sent_(0) {
61}
62
63StreamDelegateBase::~StreamDelegateBase() {
64}
65
66SpdySendStatus StreamDelegateBase::OnSendHeadersComplete() {
67  send_headers_completed_ = true;
68  return NO_MORE_DATA_TO_SEND;
69}
70
71int StreamDelegateBase::OnResponseReceived(const SpdyHeaderBlock& response,
72                                           base::Time response_time,
73                                           int status) {
74  EXPECT_TRUE(send_headers_completed_);
75  response_ = response;
76  return status;
77}
78
79void StreamDelegateBase::OnHeadersSent() {
80  headers_sent_++;
81}
82
83int StreamDelegateBase::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
84  if (buffer)
85    received_data_queue_.Enqueue(buffer.Pass());
86  return OK;
87}
88
89void StreamDelegateBase::OnDataSent(size_t bytes_sent) {
90  data_sent_ += bytes_sent;
91}
92
93void StreamDelegateBase::OnClose(int status) {
94  if (!stream_)
95    return;
96  stream_ = NULL;
97  callback_.callback().Run(status);
98}
99
100int StreamDelegateBase::WaitForClose() {
101  int result = callback_.WaitForResult();
102  EXPECT_TRUE(!stream_.get());
103  return result;
104}
105
106std::string StreamDelegateBase::TakeReceivedData() {
107  size_t len = received_data_queue_.GetTotalSize();
108  std::string received_data(len, '\0');
109  if (len > 0) {
110    EXPECT_EQ(
111        len,
112        received_data_queue_.Dequeue(string_as_array(&received_data), len));
113  }
114  return received_data;
115}
116
117std::string StreamDelegateBase::GetResponseHeaderValue(
118    const std::string& name) const {
119  SpdyHeaderBlock::const_iterator it = response_.find(name);
120  return (it == response_.end()) ? std::string() : it->second;
121}
122
123StreamDelegateSendImmediate::StreamDelegateSendImmediate(
124    const scoped_refptr<SpdyStream>& stream,
125    scoped_ptr<SpdyHeaderBlock> headers,
126    base::StringPiece data)
127    : StreamDelegateBase(stream),
128      headers_(headers.Pass()),
129      data_(data) {}
130
131StreamDelegateSendImmediate::~StreamDelegateSendImmediate() {
132}
133
134int StreamDelegateSendImmediate::OnSendBody() {
135  ADD_FAILURE() << "OnSendBody should not be called";
136  return ERR_UNEXPECTED;
137}
138SpdySendStatus StreamDelegateSendImmediate::OnSendBodyComplete(
139    size_t /*bytes_sent*/) {
140  ADD_FAILURE() << "OnSendBodyComplete should not be called";
141  return NO_MORE_DATA_TO_SEND;
142}
143
144int StreamDelegateSendImmediate::OnResponseReceived(
145    const SpdyHeaderBlock& response,
146    base::Time response_time,
147    int status) {
148  status =
149      StreamDelegateBase::OnResponseReceived(response, response_time, status);
150  if (headers_.get()) {
151    stream()->QueueHeaders(headers_.Pass());
152  }
153  if (data_.data()) {
154    scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(data_.as_string()));
155    stream()->QueueStreamData(buf, buf->size(), DATA_FLAG_NONE);
156  }
157  return status;
158}
159
160StreamDelegateWithBody::StreamDelegateWithBody(
161    const scoped_refptr<SpdyStream>& stream,
162    base::StringPiece data)
163    : StreamDelegateBase(stream),
164      buf_(new DrainableIOBuffer(new StringIOBuffer(data.as_string()),
165                                 data.size())),
166      body_data_sent_(0) {}
167
168StreamDelegateWithBody::~StreamDelegateWithBody() {
169}
170
171int StreamDelegateWithBody::OnSendBody() {
172  stream()->QueueStreamData(buf_.get(), buf_->BytesRemaining(),
173                            DATA_FLAG_NONE);
174  return ERR_IO_PENDING;
175}
176
177SpdySendStatus StreamDelegateWithBody::OnSendBodyComplete(size_t bytes_sent) {
178  EXPECT_GT(bytes_sent, 0u);
179
180  buf_->DidConsume(bytes_sent);
181  body_data_sent_ += bytes_sent;
182  if (buf_->BytesRemaining() > 0) {
183    // Go back to OnSendBody() to send the remaining data.
184    return MORE_DATA_TO_SEND;
185  }
186
187  return NO_MORE_DATA_TO_SEND;
188}
189
190} // namespace test
191
192} // namespace net
193