| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/tools/flip_server/spdy_interface.h" | |
| 6 | |
| 7 #include <list> | |
| 8 | |
| 9 #include "base/memory/scoped_ptr.h" | |
| 10 #include "base/strings/string_piece.h" | |
| 11 #include "net/spdy/buffered_spdy_framer.h" | |
| 12 #include "net/tools/balsa/balsa_enums.h" | |
| 13 #include "net/tools/balsa/balsa_headers.h" | |
| 14 #include "net/tools/flip_server/flip_config.h" | |
| 15 #include "net/tools/flip_server/flip_test_utils.h" | |
| 16 #include "net/tools/flip_server/mem_cache.h" | |
| 17 #include "testing/gmock/include/gmock/gmock.h" | |
| 18 #include "testing/gtest/include/gtest/gtest.h" | |
| 19 | |
| 20 namespace net { | |
| 21 | |
| 22 using ::base::StringPiece; | |
| 23 using ::testing::_; | |
| 24 using ::testing::InSequence; | |
| 25 using ::testing::InvokeWithoutArgs; | |
| 26 using ::testing::Return; | |
| 27 using ::testing::SaveArg; | |
| 28 using ::testing::Values; | |
| 29 | |
| 30 namespace { | |
| 31 | |
| 32 struct StringSaver { | |
| 33 public: | |
| 34 StringSaver() : data(NULL), size(0) {} | |
| 35 void Save() { string = std::string(data, size); } | |
| 36 | |
| 37 const char* data; | |
| 38 size_t size; | |
| 39 std::string string; | |
| 40 }; | |
| 41 | |
| 42 class SpdyFramerVisitor : public BufferedSpdyFramerVisitorInterface { | |
| 43 public: | |
| 44 virtual ~SpdyFramerVisitor() {} | |
| 45 MOCK_METHOD1(OnError, void(SpdyFramer::SpdyError)); | |
| 46 MOCK_METHOD2(OnStreamError, void(SpdyStreamId, const std::string&)); | |
| 47 MOCK_METHOD6(OnSynStream, | |
| 48 void(SpdyStreamId, | |
| 49 SpdyStreamId, | |
| 50 SpdyPriority, | |
| 51 bool, | |
| 52 bool, | |
| 53 const SpdyHeaderBlock&)); | |
| 54 MOCK_METHOD3(OnSynReply, void(SpdyStreamId, bool, const SpdyHeaderBlock&)); | |
| 55 MOCK_METHOD5(OnHeaders, | |
| 56 void(SpdyStreamId, | |
| 57 bool, | |
| 58 SpdyPriority, | |
| 59 bool, | |
| 60 const SpdyHeaderBlock&)); | |
| 61 MOCK_METHOD3(OnDataFrameHeader, void(SpdyStreamId, size_t, bool)); | |
| 62 MOCK_METHOD4(OnStreamFrameData, void(SpdyStreamId, | |
| 63 const char*, | |
| 64 size_t, | |
| 65 bool)); | |
| 66 MOCK_METHOD1(OnSettings, void(bool clear_persisted)); | |
| 67 MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8, uint32)); | |
| 68 MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack)); | |
| 69 MOCK_METHOD2(OnRstStream, void(SpdyStreamId, SpdyRstStreamStatus)); | |
| 70 MOCK_METHOD2(OnGoAway, void(SpdyStreamId, SpdyGoAwayStatus)); | |
| 71 MOCK_METHOD2(OnWindowUpdate, void(SpdyStreamId, uint32)); | |
| 72 MOCK_METHOD3(OnPushPromise, | |
| 73 void(SpdyStreamId, SpdyStreamId, const SpdyHeaderBlock&)); | |
| 74 MOCK_METHOD2(OnUnknownFrame, bool(SpdyStreamId stream_id, int frame_type)); | |
| 75 }; | |
| 76 | |
| 77 class FakeSMConnection : public SMConnection { | |
| 78 public: | |
| 79 FakeSMConnection(EpollServer* epoll_server, | |
| 80 SSLState* ssl_state, | |
| 81 MemoryCache* memory_cache, | |
| 82 FlipAcceptor* acceptor, | |
| 83 std::string log_prefix) | |
| 84 : SMConnection(epoll_server, | |
| 85 ssl_state, | |
| 86 memory_cache, | |
| 87 acceptor, | |
| 88 log_prefix) {} | |
| 89 | |
| 90 MOCK_METHOD0(Cleanup, void()); | |
| 91 MOCK_METHOD8(InitSMConnection, | |
| 92 void(SMConnectionPoolInterface*, | |
| 93 SMInterface*, | |
| 94 EpollServer*, | |
| 95 int, | |
| 96 std::string, | |
| 97 std::string, | |
| 98 std::string, | |
| 99 bool)); | |
| 100 }; | |
| 101 | |
| 102 // This class is almost SpdySM, except one function. | |
| 103 // This class is the test target of tests in this file. | |
| 104 class TestSpdySM : public SpdySM { | |
| 105 public: | |
| 106 virtual ~TestSpdySM() {} | |
| 107 TestSpdySM(SMConnection* connection, | |
| 108 SMInterface* sm_http_interface, | |
| 109 EpollServer* epoll_server, | |
| 110 MemoryCache* memory_cache, | |
| 111 FlipAcceptor* acceptor, | |
| 112 SpdyMajorVersion version) | |
| 113 : SpdySM(connection, | |
| 114 sm_http_interface, | |
| 115 epoll_server, | |
| 116 memory_cache, | |
| 117 acceptor, | |
| 118 version) {} | |
| 119 | |
| 120 MOCK_METHOD2(FindOrMakeNewSMConnectionInterface, | |
| 121 SMInterface*(const std::string&, const std::string&)); | |
| 122 }; | |
| 123 | |
| 124 class SpdySMTestBase : public ::testing::TestWithParam<SpdyMajorVersion> { | |
| 125 public: | |
| 126 explicit SpdySMTestBase(FlipHandlerType type) { | |
| 127 SSLState* ssl_state = NULL; | |
| 128 mock_another_interface_.reset(new MockSMInterface); | |
| 129 memory_cache_.reset(new MemoryCache); | |
| 130 acceptor_.reset(new FlipAcceptor(type, | |
| 131 "127.0.0.1", | |
| 132 "8941", | |
| 133 "ssl_cert_filename", | |
| 134 "ssl_key_filename", | |
| 135 "127.0.0.1", | |
| 136 "8942", | |
| 137 "127.0.0.1", | |
| 138 "8943", | |
| 139 1, | |
| 140 0, | |
| 141 true, | |
| 142 1, | |
| 143 false, | |
| 144 true, | |
| 145 NULL)); | |
| 146 epoll_server_.reset(new EpollServer); | |
| 147 connection_.reset(new FakeSMConnection(epoll_server_.get(), | |
| 148 ssl_state, | |
| 149 memory_cache_.get(), | |
| 150 acceptor_.get(), | |
| 151 "log_prefix")); | |
| 152 | |
| 153 interface_.reset(new TestSpdySM(connection_.get(), | |
| 154 mock_another_interface_.get(), | |
| 155 epoll_server_.get(), | |
| 156 memory_cache_.get(), | |
| 157 acceptor_.get(), | |
| 158 GetParam())); | |
| 159 | |
| 160 spdy_framer_.reset(new BufferedSpdyFramer(GetParam(), true)); | |
| 161 spdy_framer_visitor_.reset(new SpdyFramerVisitor); | |
| 162 spdy_framer_->set_visitor(spdy_framer_visitor_.get()); | |
| 163 } | |
| 164 | |
| 165 virtual ~SpdySMTestBase() { | |
| 166 if (acceptor_->listen_fd_ >= 0) { | |
| 167 epoll_server_->UnregisterFD(acceptor_->listen_fd_); | |
| 168 close(acceptor_->listen_fd_); | |
| 169 acceptor_->listen_fd_ = -1; | |
| 170 } | |
| 171 OutputList& output_list = *connection_->output_list(); | |
| 172 for (OutputList::const_iterator i = output_list.begin(); | |
| 173 i != output_list.end(); | |
| 174 ++i) { | |
| 175 delete *i; | |
| 176 } | |
| 177 output_list.clear(); | |
| 178 } | |
| 179 | |
| 180 bool HasStream(uint32 stream_id) { | |
| 181 return interface_->output_ordering().ExistsInPriorityMaps(stream_id); | |
| 182 } | |
| 183 | |
| 184 protected: | |
| 185 scoped_ptr<MockSMInterface> mock_another_interface_; | |
| 186 scoped_ptr<MemoryCache> memory_cache_; | |
| 187 scoped_ptr<FlipAcceptor> acceptor_; | |
| 188 scoped_ptr<EpollServer> epoll_server_; | |
| 189 scoped_ptr<FakeSMConnection> connection_; | |
| 190 scoped_ptr<TestSpdySM> interface_; | |
| 191 scoped_ptr<BufferedSpdyFramer> spdy_framer_; | |
| 192 scoped_ptr<SpdyFramerVisitor> spdy_framer_visitor_; | |
| 193 }; | |
| 194 | |
| 195 class SpdySMProxyTest : public SpdySMTestBase { | |
| 196 public: | |
| 197 SpdySMProxyTest() : SpdySMTestBase(FLIP_HANDLER_PROXY) {} | |
| 198 virtual ~SpdySMProxyTest() {} | |
| 199 }; | |
| 200 | |
| 201 class SpdySMServerTest : public SpdySMTestBase { | |
| 202 public: | |
| 203 SpdySMServerTest() : SpdySMTestBase(FLIP_HANDLER_SPDY_SERVER) {} | |
| 204 virtual ~SpdySMServerTest() {} | |
| 205 }; | |
| 206 | |
| 207 INSTANTIATE_TEST_CASE_P(SpdySMProxyTest, | |
| 208 SpdySMProxyTest, | |
| 209 Values(SPDY3, SPDY4)); | |
| 210 INSTANTIATE_TEST_CASE_P(SpdySMServerTest, SpdySMServerTest, Values(SPDY4)); | |
| 211 | |
| 212 TEST_P(SpdySMProxyTest, InitSMConnection) { | |
| 213 { | |
| 214 InSequence s; | |
| 215 EXPECT_CALL(*connection_, InitSMConnection(_, _, _, _, _, _, _, _)); | |
| 216 } | |
| 217 interface_->InitSMConnection( | |
| 218 NULL, NULL, epoll_server_.get(), -1, "", "", "", false); | |
| 219 } | |
| 220 | |
| 221 TEST_P(SpdySMProxyTest, OnStreamFrameData) { | |
| 222 BufferedSpdyFramerVisitorInterface* visitor = interface_.get(); | |
| 223 scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface); | |
| 224 uint32 stream_id = 92; | |
| 225 uint32 associated_id = 43; | |
| 226 SpdyHeaderBlock block; | |
| 227 testing::MockFunction<void(int)> checkpoint; // NOLINT | |
| 228 | |
| 229 scoped_ptr<SpdyFrame> frame(spdy_framer_->CreatePingFrame(12, false)); | |
| 230 block[":method"] = "GET"; | |
| 231 block[":host"] = "www.example.com"; | |
| 232 block[":path"] = "/path"; | |
| 233 block[":scheme"] = "http"; | |
| 234 block["foo"] = "bar"; | |
| 235 { | |
| 236 InSequence s; | |
| 237 EXPECT_CALL(*interface_, | |
| 238 FindOrMakeNewSMConnectionInterface(_, _)) | |
| 239 .WillOnce(Return(mock_interface.get())); | |
| 240 EXPECT_CALL(*mock_interface, SetStreamID(stream_id)); | |
| 241 EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _)).Times(1); | |
| 242 EXPECT_CALL(checkpoint, Call(0)); | |
| 243 EXPECT_CALL(*mock_interface, | |
| 244 ProcessWriteInput(frame->data(), frame->size())).Times(1); | |
| 245 } | |
| 246 | |
| 247 visitor->OnSynStream(stream_id, associated_id, 0, false, false, block); | |
| 248 checkpoint.Call(0); | |
| 249 visitor->OnStreamFrameData(stream_id, frame->data(), frame->size(), true); | |
| 250 } | |
| 251 | |
| 252 TEST_P(SpdySMProxyTest, OnRstStream) { | |
| 253 BufferedSpdyFramerVisitorInterface* visitor = interface_.get(); | |
| 254 uint32 stream_id = 82; | |
| 255 MemCacheIter mci; | |
| 256 mci.stream_id = stream_id; | |
| 257 | |
| 258 { | |
| 259 BalsaHeaders headers; | |
| 260 std::string filename = "foobar"; | |
| 261 memory_cache_->InsertFile(&headers, filename, ""); | |
| 262 mci.file_data = memory_cache_->GetFileData(filename); | |
| 263 } | |
| 264 | |
| 265 interface_->AddToOutputOrder(mci); | |
| 266 ASSERT_TRUE(HasStream(stream_id)); | |
| 267 visitor->OnRstStream(stream_id, RST_STREAM_INVALID); | |
| 268 ASSERT_FALSE(HasStream(stream_id)); | |
| 269 } | |
| 270 | |
| 271 TEST_P(SpdySMProxyTest, ProcessReadInput) { | |
| 272 ASSERT_EQ(SpdyFramer::SPDY_RESET, interface_->spdy_framer()->state()); | |
| 273 interface_->ProcessReadInput("", 1); | |
| 274 ASSERT_EQ(SpdyFramer::SPDY_READING_COMMON_HEADER, | |
| 275 interface_->spdy_framer()->state()); | |
| 276 } | |
| 277 | |
| 278 TEST_P(SpdySMProxyTest, ResetForNewConnection) { | |
| 279 uint32 stream_id = 13; | |
| 280 MemCacheIter mci; | |
| 281 mci.stream_id = stream_id; | |
| 282 // incomplete input | |
| 283 const char input[] = {'\0', '\0', '\0'}; | |
| 284 | |
| 285 { | |
| 286 BalsaHeaders headers; | |
| 287 std::string filename = "foobar"; | |
| 288 memory_cache_->InsertFile(&headers, filename, ""); | |
| 289 mci.file_data = memory_cache_->GetFileData(filename); | |
| 290 } | |
| 291 | |
| 292 interface_->AddToOutputOrder(mci); | |
| 293 ASSERT_TRUE(HasStream(stream_id)); | |
| 294 interface_->ProcessReadInput(input, sizeof(input)); | |
| 295 ASSERT_NE(SpdyFramer::SPDY_RESET, interface_->spdy_framer()->state()); | |
| 296 | |
| 297 interface_->ResetForNewConnection(); | |
| 298 ASSERT_FALSE(HasStream(stream_id)); | |
| 299 ASSERT_TRUE(interface_->spdy_framer() == NULL); | |
| 300 } | |
| 301 | |
| 302 TEST_P(SpdySMProxyTest, CreateFramer) { | |
| 303 interface_->ResetForNewConnection(); | |
| 304 interface_->CreateFramer(SPDY3); | |
| 305 ASSERT_TRUE(interface_->spdy_framer() != NULL); | |
| 306 ASSERT_EQ(interface_->spdy_version(), SPDY3); | |
| 307 | |
| 308 interface_->ResetForNewConnection(); | |
| 309 interface_->CreateFramer(SPDY4); | |
| 310 ASSERT_TRUE(interface_->spdy_framer() != NULL); | |
| 311 ASSERT_EQ(interface_->spdy_version(), SPDY4); | |
| 312 } | |
| 313 | |
| 314 TEST_P(SpdySMProxyTest, PostAcceptHook) { | |
| 315 interface_->PostAcceptHook(); | |
| 316 | |
| 317 ASSERT_EQ(1u, connection_->output_list()->size()); | |
| 318 std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin(); | |
| 319 DataFrame* df = *i++; | |
| 320 | |
| 321 { | |
| 322 InSequence s; | |
| 323 EXPECT_CALL(*spdy_framer_visitor_, OnSettings(false)); | |
| 324 EXPECT_CALL(*spdy_framer_visitor_, | |
| 325 OnSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 0u, 100u)); | |
| 326 } | |
| 327 spdy_framer_->ProcessInput(df->data, df->size); | |
| 328 } | |
| 329 | |
| 330 TEST_P(SpdySMProxyTest, NewStream) { | |
| 331 // TODO(yhirano): SpdySM::NewStream leads to crash when | |
| 332 // acceptor_->flip_handler_type_ != FLIP_HANDLER_SPDY_SERVER. | |
| 333 // It should be fixed though I don't know the solution now. | |
| 334 } | |
| 335 | |
| 336 TEST_P(SpdySMProxyTest, AddToOutputOrder) { | |
| 337 uint32 stream_id = 13; | |
| 338 MemCacheIter mci; | |
| 339 mci.stream_id = stream_id; | |
| 340 | |
| 341 { | |
| 342 BalsaHeaders headers; | |
| 343 std::string filename = "foobar"; | |
| 344 memory_cache_->InsertFile(&headers, filename, ""); | |
| 345 mci.file_data = memory_cache_->GetFileData(filename); | |
| 346 } | |
| 347 | |
| 348 interface_->AddToOutputOrder(mci); | |
| 349 ASSERT_TRUE(HasStream(stream_id)); | |
| 350 } | |
| 351 | |
| 352 TEST_P(SpdySMProxyTest, SendErrorNotFound) { | |
| 353 uint32 stream_id = 82; | |
| 354 SpdyHeaderBlock actual_header_block; | |
| 355 const char* actual_data; | |
| 356 size_t actual_size; | |
| 357 testing::MockFunction<void(int)> checkpoint; // NOLINT | |
| 358 | |
| 359 interface_->SendErrorNotFound(stream_id); | |
| 360 | |
| 361 ASSERT_EQ(2u, connection_->output_list()->size()); | |
| 362 | |
| 363 { | |
| 364 InSequence s; | |
| 365 if (GetParam() < SPDY4) { | |
| 366 EXPECT_CALL(*spdy_framer_visitor_, | |
| 367 OnSynReply(stream_id, false, _)) | |
| 368 .WillOnce(SaveArg<2>(&actual_header_block)); | |
| 369 } else { | |
| 370 EXPECT_CALL(*spdy_framer_visitor_, | |
| 371 OnHeaders(stream_id, false, 0, false, _)) | |
| 372 .WillOnce(SaveArg<4>(&actual_header_block)); | |
| 373 } | |
| 374 EXPECT_CALL(checkpoint, Call(0)); | |
| 375 EXPECT_CALL(*spdy_framer_visitor_, | |
| 376 OnDataFrameHeader(stream_id, _, true)); | |
| 377 EXPECT_CALL(*spdy_framer_visitor_, | |
| 378 OnStreamFrameData(stream_id, _, _, false)).Times(1) | |
| 379 .WillOnce(DoAll(SaveArg<1>(&actual_data), | |
| 380 SaveArg<2>(&actual_size))); | |
| 381 EXPECT_CALL(*spdy_framer_visitor_, | |
| 382 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1); | |
| 383 } | |
| 384 | |
| 385 std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin(); | |
| 386 DataFrame* df = *i++; | |
| 387 spdy_framer_->ProcessInput(df->data, df->size); | |
| 388 checkpoint.Call(0); | |
| 389 df = *i++; | |
| 390 spdy_framer_->ProcessInput(df->data, df->size); | |
| 391 | |
| 392 ASSERT_EQ(2, spdy_framer_->frames_received()); | |
| 393 ASSERT_EQ(2u, actual_header_block.size()); | |
| 394 ASSERT_EQ("404 Not Found", actual_header_block[":status"]); | |
| 395 ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]); | |
| 396 ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size)); | |
| 397 } | |
| 398 | |
| 399 TEST_P(SpdySMProxyTest, SendSynStream) { | |
| 400 uint32 stream_id = 82; | |
| 401 BalsaHeaders headers; | |
| 402 SpdyHeaderBlock actual_header_block; | |
| 403 headers.AppendHeader("key1", "value1"); | |
| 404 headers.AppendHeader("Host", "www.example.com"); | |
| 405 headers.SetRequestFirstlineFromStringPieces("GET", "/path", "HTTP/1.1"); | |
| 406 | |
| 407 interface_->SendSynStream(stream_id, headers); | |
| 408 | |
| 409 ASSERT_EQ(1u, connection_->output_list()->size()); | |
| 410 std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin(); | |
| 411 DataFrame* df = *i++; | |
| 412 | |
| 413 { | |
| 414 InSequence s; | |
| 415 EXPECT_CALL(*spdy_framer_visitor_, | |
| 416 OnSynStream(stream_id, 0, _, false, false, _)) | |
| 417 .WillOnce(SaveArg<5>(&actual_header_block)); | |
| 418 } | |
| 419 | |
| 420 spdy_framer_->ProcessInput(df->data, df->size); | |
| 421 ASSERT_EQ(1, spdy_framer_->frames_received()); | |
| 422 ASSERT_EQ(5u, actual_header_block.size()); | |
| 423 ASSERT_EQ("GET", actual_header_block[":method"]); | |
| 424 ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]); | |
| 425 ASSERT_EQ("/path", actual_header_block[":path"]); | |
| 426 ASSERT_EQ("www.example.com", actual_header_block[":host"]); | |
| 427 ASSERT_EQ("value1", actual_header_block["key1"]); | |
| 428 } | |
| 429 | |
| 430 TEST_P(SpdySMProxyTest, SendSynReply) { | |
| 431 uint32 stream_id = 82; | |
| 432 BalsaHeaders headers; | |
| 433 SpdyHeaderBlock actual_header_block; | |
| 434 headers.AppendHeader("key1", "value1"); | |
| 435 headers.SetResponseFirstlineFromStringPieces("HTTP/1.1", "200", "OK"); | |
| 436 | |
| 437 interface_->SendSynReply(stream_id, headers); | |
| 438 | |
| 439 ASSERT_EQ(1u, connection_->output_list()->size()); | |
| 440 std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin(); | |
| 441 DataFrame* df = *i++; | |
| 442 | |
| 443 { | |
| 444 InSequence s; | |
| 445 if (GetParam() < SPDY4) { | |
| 446 EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _)) | |
| 447 .WillOnce(SaveArg<2>(&actual_header_block)); | |
| 448 } else { | |
| 449 EXPECT_CALL(*spdy_framer_visitor_, | |
| 450 OnHeaders(stream_id, false, 0, false, _)) | |
| 451 .WillOnce(SaveArg<4>(&actual_header_block)); | |
| 452 } | |
| 453 } | |
| 454 | |
| 455 spdy_framer_->ProcessInput(df->data, df->size); | |
| 456 ASSERT_EQ(1, spdy_framer_->frames_received()); | |
| 457 ASSERT_EQ(3u, actual_header_block.size()); | |
| 458 ASSERT_EQ("200 OK", actual_header_block[":status"]); | |
| 459 ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]); | |
| 460 ASSERT_EQ("value1", actual_header_block["key1"]); | |
| 461 } | |
| 462 | |
| 463 TEST_P(SpdySMProxyTest, SendDataFrame) { | |
| 464 uint32 stream_id = 133; | |
| 465 SpdyDataFlags flags = DATA_FLAG_NONE; | |
| 466 const char* actual_data; | |
| 467 size_t actual_size; | |
| 468 | |
| 469 interface_->SendDataFrame(stream_id, "hello", 5, flags, true); | |
| 470 | |
| 471 ASSERT_EQ(1u, connection_->output_list()->size()); | |
| 472 std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin(); | |
| 473 DataFrame* df = *i++; | |
| 474 | |
| 475 { | |
| 476 InSequence s; | |
| 477 EXPECT_CALL(*spdy_framer_visitor_, | |
| 478 OnDataFrameHeader(stream_id, _, false)); | |
| 479 EXPECT_CALL(*spdy_framer_visitor_, | |
| 480 OnStreamFrameData(stream_id, _, _, false)) | |
| 481 .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size))); | |
| 482 } | |
| 483 | |
| 484 spdy_framer_->ProcessInput(df->data, df->size); | |
| 485 ASSERT_EQ(1, spdy_framer_->frames_received()); | |
| 486 ASSERT_EQ("hello", StringPiece(actual_data, actual_size)); | |
| 487 } | |
| 488 | |
| 489 TEST_P(SpdySMProxyTest, SendLongDataFrame) { | |
| 490 uint32 stream_id = 133; | |
| 491 SpdyDataFlags flags = DATA_FLAG_NONE; | |
| 492 const char* actual_data; | |
| 493 size_t actual_size; | |
| 494 | |
| 495 std::string data = std::string(kSpdySegmentSize, 'a') + | |
| 496 std::string(kSpdySegmentSize, 'b') + "c"; | |
| 497 interface_->SendDataFrame(stream_id, data.data(), data.size(), flags, true); | |
| 498 | |
| 499 { | |
| 500 InSequence s; | |
| 501 for (int i = 0; i < 3; ++i) { | |
| 502 EXPECT_CALL(*spdy_framer_visitor_, | |
| 503 OnDataFrameHeader(stream_id, _, false)); | |
| 504 EXPECT_CALL(*spdy_framer_visitor_, | |
| 505 OnStreamFrameData(stream_id, _, _, false)) | |
| 506 .WillOnce(DoAll(SaveArg<1>(&actual_data), | |
| 507 SaveArg<2>(&actual_size))); | |
| 508 } | |
| 509 } | |
| 510 | |
| 511 ASSERT_EQ(3u, connection_->output_list()->size()); | |
| 512 std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin(); | |
| 513 DataFrame* df = *i++; | |
| 514 spdy_framer_->ProcessInput(df->data, df->size); | |
| 515 ASSERT_EQ(std::string(kSpdySegmentSize, 'a'), | |
| 516 StringPiece(actual_data, actual_size)); | |
| 517 | |
| 518 df = *i++; | |
| 519 spdy_framer_->ProcessInput(df->data, df->size); | |
| 520 ASSERT_EQ(std::string(kSpdySegmentSize, 'b'), | |
| 521 StringPiece(actual_data, actual_size)); | |
| 522 | |
| 523 df = *i++; | |
| 524 spdy_framer_->ProcessInput(df->data, df->size); | |
| 525 ASSERT_EQ("c", StringPiece(actual_data, actual_size)); | |
| 526 } | |
| 527 | |
| 528 TEST_P(SpdySMServerTest, OnSynStream) { | |
| 529 BufferedSpdyFramerVisitorInterface* visitor = interface_.get(); | |
| 530 uint32 stream_id = 82; | |
| 531 SpdyHeaderBlock spdy_headers; | |
| 532 spdy_headers["url"] = "http://www.example.com/path"; | |
| 533 spdy_headers["method"] = "GET"; | |
| 534 spdy_headers["scheme"] = "http"; | |
| 535 spdy_headers["version"] = "HTTP/1.1"; | |
| 536 | |
| 537 { | |
| 538 BalsaHeaders headers; | |
| 539 memory_cache_->InsertFile(&headers, "GET_/path", ""); | |
| 540 } | |
| 541 visitor->OnSynStream(stream_id, 0, 0, true, true, spdy_headers); | |
| 542 ASSERT_TRUE(HasStream(stream_id)); | |
| 543 } | |
| 544 | |
| 545 TEST_P(SpdySMServerTest, NewStream) { | |
| 546 uint32 stream_id = 13; | |
| 547 std::string filename = "foobar"; | |
| 548 | |
| 549 { | |
| 550 BalsaHeaders headers; | |
| 551 memory_cache_->InsertFile(&headers, filename, ""); | |
| 552 } | |
| 553 | |
| 554 interface_->NewStream(stream_id, 0, filename); | |
| 555 ASSERT_TRUE(HasStream(stream_id)); | |
| 556 } | |
| 557 | |
| 558 TEST_P(SpdySMServerTest, NewStreamError) { | |
| 559 uint32 stream_id = 82; | |
| 560 SpdyHeaderBlock actual_header_block; | |
| 561 const char* actual_data; | |
| 562 size_t actual_size; | |
| 563 testing::MockFunction<void(int)> checkpoint; // NOLINT | |
| 564 | |
| 565 interface_->NewStream(stream_id, 0, "nonexistingfile"); | |
| 566 | |
| 567 ASSERT_EQ(2u, connection_->output_list()->size()); | |
| 568 | |
| 569 { | |
| 570 InSequence s; | |
| 571 if (GetParam() < SPDY4) { | |
| 572 EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _)) | |
| 573 .WillOnce(SaveArg<2>(&actual_header_block)); | |
| 574 } else { | |
| 575 EXPECT_CALL(*spdy_framer_visitor_, | |
| 576 OnHeaders(stream_id, false, 0, false, _)) | |
| 577 .WillOnce(SaveArg<4>(&actual_header_block)); | |
| 578 } | |
| 579 EXPECT_CALL(checkpoint, Call(0)); | |
| 580 EXPECT_CALL(*spdy_framer_visitor_, | |
| 581 OnDataFrameHeader(stream_id, _, true)); | |
| 582 EXPECT_CALL(*spdy_framer_visitor_, | |
| 583 OnStreamFrameData(stream_id, _, _, false)).Times(1) | |
| 584 .WillOnce(DoAll(SaveArg<1>(&actual_data), | |
| 585 SaveArg<2>(&actual_size))); | |
| 586 EXPECT_CALL(*spdy_framer_visitor_, | |
| 587 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1); | |
| 588 } | |
| 589 | |
| 590 std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin(); | |
| 591 DataFrame* df = *i++; | |
| 592 spdy_framer_->ProcessInput(df->data, df->size); | |
| 593 checkpoint.Call(0); | |
| 594 df = *i++; | |
| 595 spdy_framer_->ProcessInput(df->data, df->size); | |
| 596 | |
| 597 ASSERT_EQ(2, spdy_framer_->frames_received()); | |
| 598 ASSERT_EQ(2u, actual_header_block.size()); | |
| 599 ASSERT_EQ("404 Not Found", actual_header_block["status"]); | |
| 600 ASSERT_EQ("HTTP/1.1", actual_header_block["version"]); | |
| 601 ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size)); | |
| 602 } | |
| 603 | |
| 604 } // namespace | |
| 605 | |
| 606 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master