net/spdy/spdy_test_util_common.cc

   1 // Copyright (c) 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/spdy/spdy_test_util_common.h"
   6
   7 #include <cstddef>
   8
   9 #include "base/compiler_specific.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_split.h"
  13 #include "net/cert/mock_cert_verifier.h"
  14 #include "net/http/http_cache.h"
  15 #include "net/http/http_network_session.h"
  16 #include "net/http/http_network_transaction.h"
  17 #include "net/http/http_server_properties_impl.h"
  18 #include "net/socket/socket_test_util.h"
  19 #include "net/socket/ssl_client_socket.h"
  20 #include "net/socket/transport_client_socket_pool.h"
  21 #include "net/spdy/buffered_spdy_framer.h"
  22 #include "net/spdy/spdy_framer.h"
  23 #include "net/spdy/spdy_http_utils.h"
  24 #include "net/spdy/spdy_session.h"
  25 #include "net/spdy/spdy_session_pool.h"
  26 #include "net/spdy/spdy_stream.h"
  27 #include "net/url_request/url_request_job_factory_impl.h"
  28
  29 namespace net {
  30
  31 namespace {
  32
  33 bool next_proto_is_spdy(NextProto next_proto) {
  34   return next_proto >= kProtoSPDYMinimumVersion &&
  35       next_proto <= kProtoSPDYMaximumVersion;
  36 }
  37
  38 // Parses a URL into the scheme, host, and path components required for a
  39 // SPDY request.
  40 void ParseUrl(base::StringPiece url, std::string* scheme, std::string* host,
  41               std::string* path) {
  42   GURL gurl(url.as_string());
  43   path->assign(gurl.PathForRequest());
  44   scheme->assign(gurl.scheme());
  45   host->assign(gurl.host());
  46   if (gurl.has_port()) {
  47     host->append(":");
  48     host->append(gurl.port());
  49   }
  50 }
  51
  52 }  // namespace
  53
  54 NextProtoVector SpdyNextProtos() {
  55   NextProtoVector next_protos;
  56   next_protos.push_back(kProtoHTTP11);
  57   next_protos.push_back(kProtoSPDY31);
  58   next_protos.push_back(kProtoHTTP2_14);
  59   next_protos.push_back(kProtoHTTP2);
  60   next_protos.push_back(kProtoQUIC1SPDY3);
  61   return next_protos;
  62 }
  63
  64 // Chop a frame into an array of MockWrites.
  65 // |data| is the frame to chop.
  66 // |length| is the length of the frame to chop.
  67 // |num_chunks| is the number of chunks to create.
  68 MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks) {
  69   MockWrite* chunks = new MockWrite[num_chunks];
  70   int chunk_size = length / num_chunks;
  71   for (int index = 0; index < num_chunks; index++) {
  72     const char* ptr = data + (index * chunk_size);
  73     if (index == num_chunks - 1)
  74       chunk_size += length % chunk_size;  // The last chunk takes the remainder.
  75     chunks[index] = MockWrite(ASYNC, ptr, chunk_size);
  76   }
  77   return chunks;
  78 }
  79
  80 // Chop a SpdyFrame into an array of MockWrites.
  81 // |frame| is the frame to chop.
  82 // |num_chunks| is the number of chunks to create.
  83 MockWrite* ChopWriteFrame(const SpdyFrame& frame, int num_chunks) {
  84   return ChopWriteFrame(frame.data(), frame.size(), num_chunks);
  85 }
  86
  87 // Chop a frame into an array of MockReads.
  88 // |data| is the frame to chop.
  89 // |length| is the length of the frame to chop.
  90 // |num_chunks| is the number of chunks to create.
  91 MockRead* ChopReadFrame(const char* data, int length, int num_chunks) {
  92   MockRead* chunks = new MockRead[num_chunks];
  93   int chunk_size = length / num_chunks;
  94   for (int index = 0; index < num_chunks; index++) {
  95     const char* ptr = data + (index * chunk_size);
  96     if (index == num_chunks - 1)
  97       chunk_size += length % chunk_size;  // The last chunk takes the remainder.
  98     chunks[index] = MockRead(ASYNC, ptr, chunk_size);
  99   }
 100   return chunks;
 101 }
 102
 103 // Chop a SpdyFrame into an array of MockReads.
 104 // |frame| is the frame to chop.
 105 // |num_chunks| is the number of chunks to create.
 106 MockRead* ChopReadFrame(const SpdyFrame& frame, int num_chunks) {
 107   return ChopReadFrame(frame.data(), frame.size(), num_chunks);
 108 }
 109
 110 // Adds headers and values to a map.
 111 // |extra_headers| is an array of { name, value } pairs, arranged as strings
 112 // where the even entries are the header names, and the odd entries are the
 113 // header values.
 114 // |headers| gets filled in from |extra_headers|.
 115 void AppendToHeaderBlock(const char* const extra_headers[],
 116                          int extra_header_count,
 117                          SpdyHeaderBlock* headers) {
 118   std::string this_header;
 119   std::string this_value;
 120
 121   if (!extra_header_count)
 122     return;
 123
 124   // Sanity check: Non-NULL header list.
 125   DCHECK(NULL != extra_headers) << "NULL header value pair list";
 126   // Sanity check: Non-NULL header map.
 127   DCHECK(NULL != headers) << "NULL header map";
 128   // Copy in the headers.
 129   for (int i = 0; i < extra_header_count; i++) {
 130     // Sanity check: Non-empty header.
 131     DCHECK_NE('\0', *extra_headers[i * 2]) << "Empty header value pair";
 132     this_header = extra_headers[i * 2];
 133     std::string::size_type header_len = this_header.length();
 134     if (!header_len)
 135       continue;
 136     this_value = extra_headers[1 + (i * 2)];
 137     std::string new_value;
 138     if (headers->find(this_header) != headers->end()) {
 139       // More than one entry in the header.
 140       // Don't add the header again, just the append to the value,
 141       // separated by a NULL character.
 142
 143       // Adjust the value.
 144       new_value = (*headers)[this_header];
 145       // Put in a NULL separator.
 146       new_value.append(1, '\0');
 147       // Append the new value.
 148       new_value += this_value;
 149     } else {
 150       // Not a duplicate, just write the value.
 151       new_value = this_value;
 152     }
 153     (*headers)[this_header] = new_value;
 154   }
 155 }
 156
 157 // Create a MockWrite from the given SpdyFrame.
 158 MockWrite CreateMockWrite(const SpdyFrame& req) {
 159   return MockWrite(ASYNC, req.data(), req.size());
 160 }
 161
 162 // Create a MockWrite from the given SpdyFrame and sequence number.
 163 MockWrite CreateMockWrite(const SpdyFrame& req, int seq) {
 164   return CreateMockWrite(req, seq, ASYNC);
 165 }
 166
 167 // Create a MockWrite from the given SpdyFrame and sequence number.
 168 MockWrite CreateMockWrite(const SpdyFrame& req, int seq, IoMode mode) {
 169   return MockWrite(mode, req.data(), req.size(), seq);
 170 }
 171
 172 // Create a MockRead from the given SpdyFrame.
 173 MockRead CreateMockRead(const SpdyFrame& resp) {
 174   return MockRead(ASYNC, resp.data(), resp.size());
 175 }
 176
 177 // Create a MockRead from the given SpdyFrame and sequence number.
 178 MockRead CreateMockRead(const SpdyFrame& resp, int seq) {
 179   return CreateMockRead(resp, seq, ASYNC);
 180 }
 181
 182 // Create a MockRead from the given SpdyFrame and sequence number.
 183 MockRead CreateMockRead(const SpdyFrame& resp, int seq, IoMode mode) {
 184   return MockRead(mode, resp.data(), resp.size(), seq);
 185 }
 186
 187 // Combines the given SpdyFrames into the given char array and returns
 188 // the total length.
 189 int CombineFrames(const SpdyFrame** frames, int num_frames,
 190                   char* buff, int buff_len) {
 191   int total_len = 0;
 192   for (int i = 0; i < num_frames; ++i) {
 193     total_len += frames[i]->size();
 194   }
 195   DCHECK_LE(total_len, buff_len);
 196   char* ptr = buff;
 197   for (int i = 0; i < num_frames; ++i) {
 198     int len = frames[i]->size();
 199     memcpy(ptr, frames[i]->data(), len);
 200     ptr += len;
 201   }
 202   return total_len;
 203 }
 204
 205 namespace {
 206
 207 class PriorityGetter : public BufferedSpdyFramerVisitorInterface {
 208  public:
 209   PriorityGetter() : priority_(0) {}
 210   ~PriorityGetter() override {}
 211
 212   SpdyPriority priority() const {
 213     return priority_;
 214   }
 215
 216   void OnError(SpdyFramer::SpdyError error_code) override {}
 217   void OnStreamError(SpdyStreamId stream_id,
 218                      const std::string& description) override {}
 219   void OnSynStream(SpdyStreamId stream_id,
 220                    SpdyStreamId associated_stream_id,
 221                    SpdyPriority priority,
 222                    bool fin,
 223                    bool unidirectional,
 224                    const SpdyHeaderBlock& headers) override {
 225     priority_ = priority;
 226   }
 227   void OnSynReply(SpdyStreamId stream_id,
 228                   bool fin,
 229                   const SpdyHeaderBlock& headers) override {}
 230   void OnHeaders(SpdyStreamId stream_id,
 231                  bool has_priority,
 232                  SpdyPriority priority,
 233                  SpdyStreamId parent_stream_id,
 234                  bool exclusive,
 235                  bool fin,
 236                  const SpdyHeaderBlock& headers) override {
 237     if (has_priority) {
 238       priority_ = priority;
 239     }
 240   }
 241   void OnDataFrameHeader(SpdyStreamId stream_id,
 242                          size_t length,
 243                          bool fin) override {}
 244   void OnStreamFrameData(SpdyStreamId stream_id,
 245                          const char* data,
 246                          size_t len,
 247                          bool fin) override {}
 248   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {}
 249   void OnSettings(bool clear_persisted) override {}
 250   void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {}
 251   void OnPing(SpdyPingId unique_id, bool is_ack) override {}
 252   void OnRstStream(SpdyStreamId stream_id,
 253                    SpdyRstStreamStatus status) override {}
 254   void OnGoAway(SpdyStreamId last_accepted_stream_id,
 255                 SpdyGoAwayStatus status) override {}
 256   void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override {}
 257   void OnPushPromise(SpdyStreamId stream_id,
 258                      SpdyStreamId promised_stream_id,
 259                      const SpdyHeaderBlock& headers) override {}
 260   bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
 261     return false;
 262   }
 263
 264  private:
 265   SpdyPriority priority_;
 266 };
 267
 268 }  // namespace
 269
 270 bool GetSpdyPriority(SpdyMajorVersion version,
 271                      const SpdyFrame& frame,
 272                      SpdyPriority* priority) {
 273   BufferedSpdyFramer framer(version, false);
 274   PriorityGetter priority_getter;
 275   framer.set_visitor(&priority_getter);
 276   size_t frame_size = frame.size();
 277   if (framer.ProcessInput(frame.data(), frame_size) != frame_size) {
 278     return false;
 279   }
 280   *priority = priority_getter.priority();
 281   return true;
 282 }
 283
 284 base::WeakPtr<SpdyStream> CreateStreamSynchronously(
 285     SpdyStreamType type,
 286     const base::WeakPtr<SpdySession>& session,
 287     const GURL& url,
 288     RequestPriority priority,
 289     const BoundNetLog& net_log) {
 290   SpdyStreamRequest stream_request;
 291   int rv = stream_request.StartRequest(type, session, url, priority, net_log,
 292                                        CompletionCallback());
 293   return
 294       (rv == OK) ? stream_request.ReleaseStream() : base::WeakPtr<SpdyStream>();
 295 }
 296
 297 StreamReleaserCallback::StreamReleaserCallback() {}
 298
 299 StreamReleaserCallback::~StreamReleaserCallback() {}
 300
 301 CompletionCallback StreamReleaserCallback::MakeCallback(
 302     SpdyStreamRequest* request) {
 303   return base::Bind(&StreamReleaserCallback::OnComplete,
 304                     base::Unretained(this),
 305                     request);
 306 }
 307
 308 void StreamReleaserCallback::OnComplete(
 309     SpdyStreamRequest* request, int result) {
 310   if (result == OK)
 311     request->ReleaseStream()->Cancel();
 312   SetResult(result);
 313 }
 314
 315 MockECSignatureCreator::MockECSignatureCreator(crypto::ECPrivateKey* key)
 316     : key_(key) {
 317 }
 318
 319 bool MockECSignatureCreator::Sign(const uint8* data,
 320                                   int data_len,
 321                                   std::vector<uint8>* signature) {
 322   std::vector<uint8> private_key_value;
 323   key_->ExportValue(&private_key_value);
 324   std::string head = "fakesignature";
 325   std::string tail = "/fakesignature";
 326
 327   signature->clear();
 328   signature->insert(signature->end(), head.begin(), head.end());
 329   signature->insert(signature->end(), private_key_value.begin(),
 330                     private_key_value.end());
 331   signature->insert(signature->end(), '-');
 332   signature->insert(signature->end(), data, data + data_len);
 333   signature->insert(signature->end(), tail.begin(), tail.end());
 334   return true;
 335 }
 336
 337 bool MockECSignatureCreator::DecodeSignature(
 338     const std::vector<uint8>& signature,
 339     std::vector<uint8>* out_raw_sig) {
 340   *out_raw_sig = signature;
 341   return true;
 342 }
 343
 344 MockECSignatureCreatorFactory::MockECSignatureCreatorFactory() {
 345   crypto::ECSignatureCreator::SetFactoryForTesting(this);
 346 }
 347
 348 MockECSignatureCreatorFactory::~MockECSignatureCreatorFactory() {
 349   crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
 350 }
 351
 352 crypto::ECSignatureCreator* MockECSignatureCreatorFactory::Create(
 353     crypto::ECPrivateKey* key) {
 354   return new MockECSignatureCreator(key);
 355 }
 356
 357 SpdySessionDependencies::SpdySessionDependencies(NextProto protocol)
 358     : host_resolver(new MockCachingHostResolver),
 359       cert_verifier(new MockCertVerifier),
 360       transport_security_state(new TransportSecurityState),
 361       proxy_service(ProxyService::CreateDirect()),
 362       ssl_config_service(new SSLConfigServiceDefaults),
 363       socket_factory(new MockClientSocketFactory),
 364       deterministic_socket_factory(new DeterministicMockClientSocketFactory),
 365       http_auth_handler_factory(
 366           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
 367       enable_ip_pooling(true),
 368       enable_compression(false),
 369       enable_ping(false),
 370       enable_user_alternate_protocol_ports(false),
 371       protocol(protocol),
 372       session_max_recv_window_size(
 373           SpdySession::GetDefaultInitialWindowSize(protocol)),
 374       stream_max_recv_window_size(
 375           SpdySession::GetDefaultInitialWindowSize(protocol)),
 376       time_func(&base::TimeTicks::Now),
 377       use_alternative_services(false),
 378       net_log(NULL) {
 379   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 380
 381   // Note: The CancelledTransaction test does cleanup by running all
 382   // tasks in the message loop (RunAllPending).  Unfortunately, that
 383   // doesn't clean up tasks on the host resolver thread; and
 384   // TCPConnectJob is currently not cancellable.  Using synchronous
 385   // lookups allows the test to shutdown cleanly.  Until we have
 386   // cancellable TCPConnectJobs, use synchronous lookups.
 387   host_resolver->set_synchronous_mode(true);
 388 }
 389
 390 SpdySessionDependencies::SpdySessionDependencies(NextProto protocol,
 391                                                  ProxyService* proxy_service)
 392     : host_resolver(new MockHostResolver),
 393       cert_verifier(new MockCertVerifier),
 394       transport_security_state(new TransportSecurityState),
 395       proxy_service(proxy_service),
 396       ssl_config_service(new SSLConfigServiceDefaults),
 397       socket_factory(new MockClientSocketFactory),
 398       deterministic_socket_factory(new DeterministicMockClientSocketFactory),
 399       http_auth_handler_factory(
 400           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
 401       enable_ip_pooling(true),
 402       enable_compression(false),
 403       enable_ping(false),
 404       enable_user_alternate_protocol_ports(false),
 405       protocol(protocol),
 406       session_max_recv_window_size(
 407           SpdySession::GetDefaultInitialWindowSize(protocol)),
 408       stream_max_recv_window_size(
 409           SpdySession::GetDefaultInitialWindowSize(protocol)),
 410       time_func(&base::TimeTicks::Now),
 411       use_alternative_services(true),
 412       net_log(NULL) {
 413   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 414 }
 415
 416 SpdySessionDependencies::~SpdySessionDependencies() {}
 417
 418 // static
 419 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSession(
 420     SpdySessionDependencies* session_deps) {
 421   HttpNetworkSession::Params params = CreateSessionParams(session_deps);
 422   params.client_socket_factory = session_deps->socket_factory.get();
 423   HttpNetworkSession* http_session = new HttpNetworkSession(params);
 424   SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
 425   pool_peer.SetEnableSendingInitialData(false);
 426   return http_session;
 427 }
 428
 429 // static
 430 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSessionDeterministic(
 431     SpdySessionDependencies* session_deps) {
 432   HttpNetworkSession::Params params = CreateSessionParams(session_deps);
 433   params.client_socket_factory =
 434       session_deps->deterministic_socket_factory.get();
 435   HttpNetworkSession* http_session = new HttpNetworkSession(params);
 436   SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
 437   pool_peer.SetEnableSendingInitialData(false);
 438   return http_session;
 439 }
 440
 441 // static
 442 HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
 443     SpdySessionDependencies* session_deps) {
 444   DCHECK(next_proto_is_spdy(session_deps->protocol)) <<
 445       "Invalid protocol: " << session_deps->protocol;
 446
 447   HttpNetworkSession::Params params;
 448   params.host_resolver = session_deps->host_resolver.get();
 449   params.cert_verifier = session_deps->cert_verifier.get();
 450   params.transport_security_state =
 451       session_deps->transport_security_state.get();
 452   params.proxy_service = session_deps->proxy_service.get();
 453   params.ssl_config_service = session_deps->ssl_config_service.get();
 454   params.http_auth_handler_factory =
 455       session_deps->http_auth_handler_factory.get();
 456   params.http_server_properties =
 457       session_deps->http_server_properties.GetWeakPtr();
 458   params.enable_spdy_compression = session_deps->enable_compression;
 459   params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
 460   params.enable_user_alternate_protocol_ports =
 461       session_deps->enable_user_alternate_protocol_ports;
 462   params.spdy_default_protocol = session_deps->protocol;
 463   params.spdy_session_max_recv_window_size =
 464       session_deps->session_max_recv_window_size;
 465   params.spdy_stream_max_recv_window_size =
 466       session_deps->stream_max_recv_window_size;
 467   params.time_func = session_deps->time_func;
 468   params.next_protos = session_deps->next_protos;
 469   params.trusted_spdy_proxy = session_deps->trusted_spdy_proxy;
 470   params.use_alternative_services = session_deps->use_alternative_services;
 471   params.net_log = session_deps->net_log;
 472   return params;
 473 }
 474
 475 SpdyURLRequestContext::SpdyURLRequestContext(NextProto protocol)
 476     : storage_(this) {
 477   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 478
 479   storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver));
 480   storage_.set_cert_verifier(new MockCertVerifier);
 481   storage_.set_transport_security_state(new TransportSecurityState);
 482   storage_.set_proxy_service(ProxyService::CreateDirect());
 483   storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
 484   storage_.set_http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault(
 485       host_resolver()));
 486   storage_.set_http_server_properties(
 487       scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
 488   storage_.set_job_factory(new URLRequestJobFactoryImpl());
 489   HttpNetworkSession::Params params;
 490   params.client_socket_factory = &socket_factory_;
 491   params.host_resolver = host_resolver();
 492   params.cert_verifier = cert_verifier();
 493   params.transport_security_state = transport_security_state();
 494   params.proxy_service = proxy_service();
 495   params.ssl_config_service = ssl_config_service();
 496   params.http_auth_handler_factory = http_auth_handler_factory();
 497   params.network_delegate = network_delegate();
 498   params.enable_spdy_compression = false;
 499   params.enable_spdy_ping_based_connection_checking = false;
 500   params.spdy_default_protocol = protocol;
 501   params.http_server_properties = http_server_properties();
 502   scoped_refptr<HttpNetworkSession> network_session(
 503       new HttpNetworkSession(params));
 504   SpdySessionPoolPeer pool_peer(network_session->spdy_session_pool());
 505   pool_peer.SetEnableSendingInitialData(false);
 506   storage_.set_http_transaction_factory(new HttpCache(
 507       network_session.get(), HttpCache::DefaultBackend::InMemory(0)));
 508 }
 509
 510 SpdyURLRequestContext::~SpdyURLRequestContext() {
 511   AssertNoURLRequests();
 512 }
 513
 514 bool HasSpdySession(SpdySessionPool* pool, const SpdySessionKey& key) {
 515   return pool->FindAvailableSession(key, BoundNetLog()) != NULL;
 516 }
 517
 518 namespace {
 519
 520 base::WeakPtr<SpdySession> CreateSpdySessionHelper(
 521     const scoped_refptr<HttpNetworkSession>& http_session,
 522     const SpdySessionKey& key,
 523     const BoundNetLog& net_log,
 524     Error expected_status,
 525     bool is_secure) {
 526   EXPECT_FALSE(HasSpdySession(http_session->spdy_session_pool(), key));
 527
 528   scoped_refptr<TransportSocketParams> transport_params(
 529       new TransportSocketParams(
 530           key.host_port_pair(), false, false, OnHostResolutionCallback(),
 531           TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
 532
 533   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
 534   TestCompletionCallback callback;
 535
 536   int rv = ERR_UNEXPECTED;
 537   if (is_secure) {
 538     SSLConfig ssl_config;
 539     scoped_refptr<SSLSocketParams> ssl_params(
 540         new SSLSocketParams(transport_params,
 541                             NULL,
 542                             NULL,
 543                             key.host_port_pair(),
 544                             ssl_config,
 545                             key.privacy_mode(),
 546                             0,
 547                             false));
 548     rv = connection->Init(key.host_port_pair().ToString(),
 549                           ssl_params,
 550                           MEDIUM,
 551                           callback.callback(),
 552                           http_session->GetSSLSocketPool(
 553                               HttpNetworkSession::NORMAL_SOCKET_POOL),
 554                           net_log);
 555   } else {
 556     rv = connection->Init(key.host_port_pair().ToString(),
 557                           transport_params,
 558                           MEDIUM,
 559                           callback.callback(),
 560                           http_session->GetTransportSocketPool(
 561                               HttpNetworkSession::NORMAL_SOCKET_POOL),
 562                           net_log);
 563   }
 564
 565   if (rv == ERR_IO_PENDING)
 566     rv = callback.WaitForResult();
 567
 568   EXPECT_EQ(OK, rv);
 569
 570   base::WeakPtr<SpdySession> spdy_session =
 571       http_session->spdy_session_pool()->CreateAvailableSessionFromSocket(
 572           key, connection.Pass(), net_log, OK, is_secure);
 573   // Failure is reported asynchronously.
 574   EXPECT_TRUE(spdy_session != NULL);
 575   EXPECT_TRUE(HasSpdySession(http_session->spdy_session_pool(), key));
 576   return spdy_session;
 577 }
 578
 579 }  // namespace
 580
 581 base::WeakPtr<SpdySession> CreateInsecureSpdySession(
 582     const scoped_refptr<HttpNetworkSession>& http_session,
 583     const SpdySessionKey& key,
 584     const BoundNetLog& net_log) {
 585   return CreateSpdySessionHelper(http_session, key, net_log,
 586                                  OK, false /* is_secure */);
 587 }
 588
 589 base::WeakPtr<SpdySession> TryCreateInsecureSpdySessionExpectingFailure(
 590     const scoped_refptr<HttpNetworkSession>& http_session,
 591     const SpdySessionKey& key,
 592     Error expected_error,
 593     const BoundNetLog& net_log) {
 594   DCHECK_LT(expected_error, ERR_IO_PENDING);
 595   return CreateSpdySessionHelper(http_session, key, net_log,
 596                                  expected_error, false /* is_secure */);
 597 }
 598
 599 base::WeakPtr<SpdySession> CreateSecureSpdySession(
 600     const scoped_refptr<HttpNetworkSession>& http_session,
 601     const SpdySessionKey& key,
 602     const BoundNetLog& net_log) {
 603   return CreateSpdySessionHelper(http_session, key, net_log,
 604                                  OK, true /* is_secure */);
 605 }
 606
 607 namespace {
 608
 609 // A ClientSocket used for CreateFakeSpdySession() below.
 610 class FakeSpdySessionClientSocket : public MockClientSocket {
 611  public:
 612   explicit FakeSpdySessionClientSocket(int read_result)
 613       : MockClientSocket(BoundNetLog()), read_result_(read_result) {}
 614
 615   ~FakeSpdySessionClientSocket() override {}
 616
 617   int Read(IOBuffer* buf,
 618            int buf_len,
 619            const CompletionCallback& callback) override {
 620     return read_result_;
 621   }
 622
 623   int Write(IOBuffer* buf,
 624             int buf_len,
 625             const CompletionCallback& callback) override {
 626     return ERR_IO_PENDING;
 627   }
 628
 629   // Return kProtoUnknown to use the pool's default protocol.
 630   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
 631
 632   // The functions below are not expected to be called.
 633
 634   int Connect(const CompletionCallback& callback) override {
 635     ADD_FAILURE();
 636     return ERR_UNEXPECTED;
 637   }
 638
 639   bool WasEverUsed() const override {
 640     ADD_FAILURE();
 641     return false;
 642   }
 643
 644   bool UsingTCPFastOpen() const override {
 645     ADD_FAILURE();
 646     return false;
 647   }
 648
 649   bool WasNpnNegotiated() const override {
 650     ADD_FAILURE();
 651     return false;
 652   }
 653
 654   bool GetSSLInfo(SSLInfo* ssl_info) override {
 655     ADD_FAILURE();
 656     return false;
 657   }
 658
 659  private:
 660   int read_result_;
 661 };
 662
 663 base::WeakPtr<SpdySession> CreateFakeSpdySessionHelper(
 664     SpdySessionPool* pool,
 665     const SpdySessionKey& key,
 666     Error expected_status) {
 667   EXPECT_NE(expected_status, ERR_IO_PENDING);
 668   EXPECT_FALSE(HasSpdySession(pool, key));
 669   scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
 670   handle->SetSocket(scoped_ptr<StreamSocket>(new FakeSpdySessionClientSocket(
 671       expected_status == OK ? ERR_IO_PENDING : expected_status)));
 672   base::WeakPtr<SpdySession> spdy_session =
 673       pool->CreateAvailableSessionFromSocket(
 674           key, handle.Pass(), BoundNetLog(), OK, true /* is_secure */);
 675   // Failure is reported asynchronously.
 676   EXPECT_TRUE(spdy_session != NULL);
 677   EXPECT_TRUE(HasSpdySession(pool, key));
 678   return spdy_session;
 679 }
 680
 681 }  // namespace
 682
 683 base::WeakPtr<SpdySession> CreateFakeSpdySession(SpdySessionPool* pool,
 684                                                  const SpdySessionKey& key) {
 685   return CreateFakeSpdySessionHelper(pool, key, OK);
 686 }
 687
 688 base::WeakPtr<SpdySession> TryCreateFakeSpdySessionExpectingFailure(
 689     SpdySessionPool* pool,
 690     const SpdySessionKey& key,
 691     Error expected_error) {
 692   DCHECK_LT(expected_error, ERR_IO_PENDING);
 693   return CreateFakeSpdySessionHelper(pool, key, expected_error);
 694 }
 695
 696 SpdySessionPoolPeer::SpdySessionPoolPeer(SpdySessionPool* pool) : pool_(pool) {
 697 }
 698
 699 void SpdySessionPoolPeer::RemoveAliases(const SpdySessionKey& key) {
 700   pool_->RemoveAliases(key);
 701 }
 702
 703 void SpdySessionPoolPeer::DisableDomainAuthenticationVerification() {
 704   pool_->verify_domain_authentication_ = false;
 705 }
 706
 707 void SpdySessionPoolPeer::SetEnableSendingInitialData(bool enabled) {
 708   pool_->enable_sending_initial_data_ = enabled;
 709 }
 710
 711 void SpdySessionPoolPeer::SetSessionMaxRecvWindowSize(size_t window) {
 712   pool_->session_max_recv_window_size_ = window;
 713 }
 714
 715 void SpdySessionPoolPeer::SetStreamInitialRecvWindowSize(size_t window) {
 716   pool_->stream_max_recv_window_size_ = window;
 717 }
 718
 719 SpdyTestUtil::SpdyTestUtil(NextProto protocol)
 720     : protocol_(protocol),
 721       spdy_version_(NextProtoToSpdyMajorVersion(protocol)),
 722       default_url_(GURL(kDefaultURL)) {
 723   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 724 }
 725
 726 void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
 727                                        SpdyHeaderBlock* headers) const {
 728   std::string scheme, host, path;
 729   ParseUrl(url, &scheme, &host, &path);
 730   (*headers)[GetSchemeKey()] = scheme;
 731   (*headers)[GetHostKey()] = host;
 732   (*headers)[GetPathKey()] = path;
 733 }
 734
 735 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
 736     base::StringPiece url) const {
 737   return ConstructHeaderBlock("GET", url, NULL);
 738 }
 739
 740 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlockForProxy(
 741     base::StringPiece url) const {
 742   scoped_ptr<SpdyHeaderBlock> headers(ConstructGetHeaderBlock(url));
 743   return headers.Pass();
 744 }
 745
 746 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeadHeaderBlock(
 747     base::StringPiece url,
 748     int64 content_length) const {
 749   return ConstructHeaderBlock("HEAD", url, nullptr);
 750 }
 751
 752 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPostHeaderBlock(
 753     base::StringPiece url,
 754     int64 content_length) const {
 755   return ConstructHeaderBlock("POST", url, &content_length);
 756 }
 757
 758 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPutHeaderBlock(
 759     base::StringPiece url,
 760     int64 content_length) const {
 761   return ConstructHeaderBlock("PUT", url, &content_length);
 762 }
 763
 764 SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(
 765     const SpdyHeaderInfo& header_info,
 766     scoped_ptr<SpdyHeaderBlock> headers) const {
 767   BufferedSpdyFramer framer(spdy_version_, header_info.compressed);
 768   SpdyFrame* frame = NULL;
 769   switch (header_info.kind) {
 770     case DATA:
 771       frame = framer.CreateDataFrame(header_info.id, header_info.data,
 772                                      header_info.data_length,
 773                                      header_info.data_flags);
 774       break;
 775     case SYN_STREAM:
 776       {
 777         frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
 778                                        header_info.priority,
 779                                        header_info.control_flags,
 780                                        headers.get());
 781       }
 782       break;
 783     case SYN_REPLY:
 784       frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
 785                                     headers.get());
 786       break;
 787     case RST_STREAM:
 788       frame = framer.CreateRstStream(header_info.id, header_info.status);
 789       break;
 790     case HEADERS:
 791       frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
 792                                    header_info.priority,
 793                                    headers.get());
 794       break;
 795     default:
 796       ADD_FAILURE();
 797       break;
 798   }
 799   return frame;
 800 }
 801
 802 SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
 803                                             const char* const extra_headers[],
 804                                             int extra_header_count,
 805                                             const char* const tail_headers[],
 806                                             int tail_header_count) const {
 807   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
 808   AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
 809   if (tail_headers && tail_header_count)
 810     AppendToHeaderBlock(tail_headers, tail_header_count, headers.get());
 811   return ConstructSpdyFrame(header_info, headers.Pass());
 812 }
 813
 814 SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
 815     scoped_ptr<SpdyHeaderBlock> headers,
 816     bool compressed,
 817     SpdyStreamId stream_id,
 818     RequestPriority request_priority,
 819     SpdyFrameType type,
 820     SpdyControlFlags flags,
 821     SpdyStreamId associated_stream_id) const {
 822   EXPECT_GE(type, DATA);
 823   EXPECT_LE(type, PRIORITY);
 824   const SpdyHeaderInfo header_info = {
 825     type,
 826     stream_id,
 827     associated_stream_id,
 828     ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
 829     0,  // credential slot
 830     flags,
 831     compressed,
 832     RST_STREAM_INVALID,  // status
 833     NULL,  // data
 834     0,  // length
 835     DATA_FLAG_NONE
 836   };
 837   return ConstructSpdyFrame(header_info, headers.Pass());
 838 }
 839
 840 SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
 841     const char* const extra_headers[],
 842     int extra_header_count,
 843     bool compressed,
 844     SpdyStreamId stream_id,
 845     RequestPriority request_priority,
 846     SpdyFrameType type,
 847     SpdyControlFlags flags,
 848     const char* const* tail_headers,
 849     int tail_header_size,
 850     SpdyStreamId associated_stream_id) const {
 851   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
 852   AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
 853   if (tail_headers && tail_header_size)
 854     AppendToHeaderBlock(tail_headers, tail_header_size / 2, headers.get());
 855   return ConstructSpdyControlFrame(
 856       headers.Pass(), compressed, stream_id,
 857       request_priority, type, flags, associated_stream_id);
 858 }
 859
 860 std::string SpdyTestUtil::ConstructSpdyReplyString(
 861     const SpdyHeaderBlock& headers) const {
 862   std::string reply_string;
 863   for (SpdyHeaderBlock::const_iterator it = headers.begin();
 864        it != headers.end(); ++it) {
 865     std::string key = it->first;
 866     // Remove leading colon from "special" headers (for SPDY3 and
 867     // above).
 868     if (spdy_version() >= SPDY3 && key[0] == ':')
 869       key = key.substr(1);
 870     for (const std::string& value :
 871          base::SplitString(it->second, base::StringPiece("\0", 1),
 872                            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
 873       reply_string += key + ": " + value + "\n";
 874     }
 875   }
 876   return reply_string;
 877 }
 878
 879 // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
 880 // SpdySettingsIR).
 881 SpdyFrame* SpdyTestUtil::ConstructSpdySettings(
 882     const SettingsMap& settings) const {
 883   SpdySettingsIR settings_ir;
 884   for (SettingsMap::const_iterator it = settings.begin();
 885        it != settings.end();
 886        ++it) {
 887     settings_ir.AddSetting(
 888         it->first,
 889         (it->second.first & SETTINGS_FLAG_PLEASE_PERSIST) != 0,
 890         (it->second.first & SETTINGS_FLAG_PERSISTED) != 0,
 891         it->second.second);
 892   }
 893   return CreateFramer(false)->SerializeFrame(settings_ir);
 894 }
 895
 896 SpdyFrame* SpdyTestUtil::ConstructSpdySettingsAck() const {
 897   char kEmptyWrite[] = "";
 898
 899   if (spdy_version() > SPDY3) {
 900     SpdySettingsIR settings_ir;
 901     settings_ir.set_is_ack(true);
 902     return CreateFramer(false)->SerializeFrame(settings_ir);
 903   }
 904   // No settings ACK write occurs. Create an empty placeholder write.
 905   return new SpdyFrame(kEmptyWrite, 0, false);
 906 }
 907
 908 SpdyFrame* SpdyTestUtil::ConstructSpdyPing(uint32 ping_id, bool is_ack) const {
 909   SpdyPingIR ping_ir(ping_id);
 910   ping_ir.set_is_ack(is_ack);
 911   return CreateFramer(false)->SerializeFrame(ping_ir);
 912 }
 913
 914 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway() const {
 915   return ConstructSpdyGoAway(0);
 916 }
 917
 918 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway(
 919     SpdyStreamId last_good_stream_id) const {
 920   SpdyGoAwayIR go_ir(last_good_stream_id, GOAWAY_OK, "go away");
 921   return CreateFramer(false)->SerializeFrame(go_ir);
 922 }
 923
 924 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway(SpdyStreamId last_good_stream_id,
 925                                              SpdyGoAwayStatus status,
 926                                              const std::string& desc) const {
 927   SpdyGoAwayIR go_ir(last_good_stream_id, status, desc);
 928   return CreateFramer(false)->SerializeFrame(go_ir);
 929 }
 930
 931 SpdyFrame* SpdyTestUtil::ConstructSpdyWindowUpdate(
 932     const SpdyStreamId stream_id, uint32 delta_window_size) const {
 933   SpdyWindowUpdateIR update_ir(stream_id, delta_window_size);
 934   return CreateFramer(false)->SerializeFrame(update_ir);
 935 }
 936
 937 // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
 938 // SpdyRstStreamIR).
 939 SpdyFrame* SpdyTestUtil::ConstructSpdyRstStream(
 940     SpdyStreamId stream_id,
 941     SpdyRstStreamStatus status) const {
 942   SpdyRstStreamIR rst_ir(stream_id, status, "");
 943   return CreateFramer(false)->SerializeRstStream(rst_ir);
 944 }
 945
 946 SpdyFrame* SpdyTestUtil::ConstructSpdyGet(
 947     const char* const url,
 948     bool compressed,
 949     SpdyStreamId stream_id,
 950     RequestPriority request_priority) const {
 951   scoped_ptr<SpdyHeaderBlock> block(ConstructGetHeaderBlock(url));
 952   return ConstructSpdySyn(
 953       stream_id, *block, request_priority, compressed, true);
 954 }
 955
 956 SpdyFrame* SpdyTestUtil::ConstructSpdyGet(const char* const extra_headers[],
 957                                           int extra_header_count,
 958                                           bool compressed,
 959                                           int stream_id,
 960                                           RequestPriority request_priority,
 961                                           bool direct) const {
 962   SpdyHeaderBlock block;
 963   AddUrlToHeaderBlock(default_url_.spec(), &block);
 964   block[GetMethodKey()] = "GET";
 965   MaybeAddVersionHeader(&block);
 966   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
 967   return ConstructSpdySyn(stream_id, block, request_priority, compressed, true);
 968 }
 969
 970 SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
 971     const char* const extra_headers[],
 972     int extra_header_count,
 973     int stream_id,
 974     RequestPriority priority,
 975     const HostPortPair& host_port_pair) const {
 976   SpdyHeaderBlock block;
 977   block[GetMethodKey()] = "CONNECT";
 978   if (spdy_version() < HTTP2) {
 979     block[GetPathKey()] = host_port_pair.ToString();
 980     block[GetHostKey()] = (host_port_pair.port() == 443)
 981                               ? host_port_pair.host()
 982                               : host_port_pair.ToString();
 983   } else {
 984     block[GetHostKey()] = host_port_pair.ToString();
 985   }
 986
 987   MaybeAddVersionHeader(&block);
 988   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
 989   return ConstructSpdySyn(stream_id, block, priority, false, false);
 990 }
 991
 992 SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
 993                                            int extra_header_count,
 994                                            int stream_id,
 995                                            int associated_stream_id,
 996                                            const char* url) {
 997   if (spdy_version() < HTTP2) {
 998     SpdySynStreamIR syn_stream(stream_id);
 999     syn_stream.set_associated_to_stream_id(associated_stream_id);
1000     syn_stream.SetHeader("hello", "bye");
1001     syn_stream.SetHeader(GetStatusKey(), "200 OK");
1002     syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
1003     AddUrlToHeaderBlock(url, syn_stream.mutable_header_block());
1004     AppendToHeaderBlock(extra_headers, extra_header_count,
1005                         syn_stream.mutable_header_block());
1006     return CreateFramer(false)->SerializeFrame(syn_stream);
1007   } else {
1008     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
1009     AddUrlToHeaderBlock(url, push_promise.mutable_header_block());
1010     scoped_ptr<SpdyFrame> push_promise_frame(
1011         CreateFramer(false)->SerializeFrame(push_promise));
1012
1013     SpdyHeadersIR headers(stream_id);
1014     headers.SetHeader("hello", "bye");
1015     headers.SetHeader(GetStatusKey(), "200 OK");
1016     AppendToHeaderBlock(extra_headers, extra_header_count,
1017                         headers.mutable_header_block());
1018     scoped_ptr<SpdyFrame> headers_frame(
1019         CreateFramer(false)->SerializeFrame(headers));
1020
1021     int joint_data_size = push_promise_frame->size() + headers_frame->size();
1022     scoped_ptr<char[]> data(new char[joint_data_size]);
1023     const SpdyFrame* frames[2] = {
1024         push_promise_frame.get(), headers_frame.get(),
1025     };
1026     int combined_size =
1027         CombineFrames(frames, arraysize(frames), data.get(), joint_data_size);
1028     DCHECK_EQ(combined_size, joint_data_size);
1029     return new SpdyFrame(data.release(), joint_data_size, true);
1030   }
1031 }
1032
1033 SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
1034                                            int extra_header_count,
1035                                            int stream_id,
1036                                            int associated_stream_id,
1037                                            const char* url,
1038                                            const char* status,
1039                                            const char* location) {
1040   if (spdy_version() < HTTP2) {
1041     SpdySynStreamIR syn_stream(stream_id);
1042     syn_stream.set_associated_to_stream_id(associated_stream_id);
1043     syn_stream.SetHeader("hello", "bye");
1044     syn_stream.SetHeader(GetStatusKey(), status);
1045     syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
1046     syn_stream.SetHeader("location", location);
1047     AddUrlToHeaderBlock(url, syn_stream.mutable_header_block());
1048     AppendToHeaderBlock(extra_headers, extra_header_count,
1049                         syn_stream.mutable_header_block());
1050     return CreateFramer(false)->SerializeFrame(syn_stream);
1051   } else {
1052     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
1053     AddUrlToHeaderBlock(url, push_promise.mutable_header_block());
1054     scoped_ptr<SpdyFrame> push_promise_frame(
1055         CreateFramer(false)->SerializeFrame(push_promise));
1056
1057     SpdyHeadersIR headers(stream_id);
1058     headers.SetHeader("hello", "bye");
1059     headers.SetHeader(GetStatusKey(), status);
1060     headers.SetHeader("location", location);
1061     AppendToHeaderBlock(extra_headers, extra_header_count,
1062                         headers.mutable_header_block());
1063     scoped_ptr<SpdyFrame> headers_frame(
1064         CreateFramer(false)->SerializeFrame(headers));
1065
1066     int joint_data_size = push_promise_frame->size() + headers_frame->size();
1067     scoped_ptr<char[]> data(new char[joint_data_size]);
1068     const SpdyFrame* frames[2] = {
1069         push_promise_frame.get(), headers_frame.get(),
1070     };
1071     int combined_size =
1072         CombineFrames(frames, arraysize(frames), data.get(), joint_data_size);
1073     DCHECK_EQ(combined_size, joint_data_size);
1074     return new SpdyFrame(data.release(), joint_data_size, true);
1075   }
1076 }
1077
1078 SpdyFrame* SpdyTestUtil::ConstructInitialSpdyPushFrame(
1079     scoped_ptr<SpdyHeaderBlock> headers,
1080     int stream_id,
1081     int associated_stream_id) {
1082   if (spdy_version() < HTTP2) {
1083     SpdySynStreamIR syn_stream(stream_id);
1084     syn_stream.set_associated_to_stream_id(associated_stream_id);
1085     SetPriority(LOWEST, &syn_stream);
1086     syn_stream.set_header_block(*headers);
1087     return CreateFramer(false)->SerializeFrame(syn_stream);
1088   } else {
1089     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
1090     push_promise.set_header_block(*headers);
1091     return CreateFramer(false)->SerializeFrame(push_promise);
1092   }
1093 }
1094
1095 SpdyFrame* SpdyTestUtil::ConstructSpdyPushHeaders(
1096     int stream_id,
1097     const char* const extra_headers[],
1098     int extra_header_count) {
1099   SpdyHeadersIR headers(stream_id);
1100   headers.SetHeader(GetStatusKey(), "200 OK");
1101   MaybeAddVersionHeader(&headers);
1102   AppendToHeaderBlock(extra_headers, extra_header_count,
1103                       headers.mutable_header_block());
1104   return CreateFramer(false)->SerializeFrame(headers);
1105 }
1106
1107 SpdyFrame* SpdyTestUtil::ConstructSpdyHeaderFrame(int stream_id,
1108                                                   const char* const headers[],
1109                                                   int header_count) {
1110   SpdyHeadersIR spdy_headers(stream_id);
1111   AppendToHeaderBlock(headers, header_count,
1112                       spdy_headers.mutable_header_block());
1113   return CreateFramer(false)->SerializeFrame(spdy_headers);
1114 }
1115
1116 SpdyFrame* SpdyTestUtil::ConstructSpdySyn(int stream_id,
1117                                           const SpdyHeaderBlock& block,
1118                                           RequestPriority priority,
1119                                           bool compressed,
1120                                           bool fin) const {
1121   if (protocol_ < kProtoHTTP2MinimumVersion) {
1122     SpdySynStreamIR syn_stream(stream_id);
1123     syn_stream.set_header_block(block);
1124     syn_stream.set_priority(
1125         ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
1126     syn_stream.set_fin(fin);
1127     return CreateFramer(compressed)->SerializeFrame(syn_stream);
1128   } else {
1129     SpdyHeadersIR headers(stream_id);
1130     headers.set_header_block(block);
1131     headers.set_has_priority(true);
1132     headers.set_priority(
1133         ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
1134     headers.set_fin(fin);
1135     return CreateFramer(compressed)->SerializeFrame(headers);
1136   }
1137 }
1138
1139 SpdyFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
1140                                             const SpdyHeaderBlock& headers) {
1141   if (protocol_ < kProtoHTTP2MinimumVersion) {
1142     SpdySynReplyIR syn_reply(stream_id);
1143     syn_reply.set_header_block(headers);
1144     return CreateFramer(false)->SerializeFrame(syn_reply);
1145   } else {
1146     SpdyHeadersIR reply(stream_id);
1147     reply.set_header_block(headers);
1148     return CreateFramer(false)->SerializeFrame(reply);
1149   }
1150 }
1151
1152 SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(
1153     const char* const status,
1154     const char* const* const extra_headers,
1155     int extra_header_count,
1156     int stream_id) {
1157   SpdyHeaderBlock block;
1158   block["hello"] = "bye";
1159   block[GetStatusKey()] = status;
1160   MaybeAddVersionHeader(&block);
1161   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
1162
1163   return ConstructSpdyReply(stream_id, block);
1164 }
1165
1166 SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReplyRedirect(int stream_id) {
1167   static const char* const kExtraHeaders[] = {
1168     "location", "http://www.foo.com/index.php",
1169   };
1170   return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
1171                                     arraysize(kExtraHeaders)/2, stream_id);
1172 }
1173
1174 SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(int stream_id) {
1175   return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
1176 }
1177
1178 SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReply(
1179     const char* const extra_headers[],
1180     int extra_header_count,
1181     int stream_id) {
1182   SpdyHeaderBlock block;
1183   block["hello"] = "bye";
1184   block[GetStatusKey()] = "200";
1185   MaybeAddVersionHeader(&block);
1186   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
1187
1188   return ConstructSpdyReply(stream_id, block);
1189 }
1190
1191 SpdyFrame* SpdyTestUtil::ConstructSpdyPost(const char* url,
1192                                            SpdyStreamId stream_id,
1193                                            int64 content_length,
1194                                            RequestPriority priority,
1195                                            const char* const extra_headers[],
1196                                            int extra_header_count) {
1197   scoped_ptr<SpdyHeaderBlock> block(
1198       ConstructPostHeaderBlock(url, content_length));
1199   AppendToHeaderBlock(extra_headers, extra_header_count, block.get());
1200   return ConstructSpdySyn(stream_id, *block, priority, false, false);
1201 }
1202
1203 SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
1204     const char* const extra_headers[],
1205     int extra_header_count) {
1206   SpdyHeaderBlock block;
1207   block[GetMethodKey()] = "POST";
1208   AddUrlToHeaderBlock(default_url_.spec(), &block);
1209   MaybeAddVersionHeader(&block);
1210   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
1211   return ConstructSpdySyn(1, block, LOWEST, false, false);
1212 }
1213
1214 SpdyFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
1215     const char* const extra_headers[],
1216     int extra_header_count) {
1217   // TODO(jgraettinger): Remove this method.
1218   return ConstructSpdyGetSynReply(NULL, 0, 1);
1219 }
1220
1221 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id, bool fin) {
1222   SpdyFramer framer(spdy_version_);
1223   SpdyDataIR data_ir(stream_id,
1224                      base::StringPiece(kUploadData, kUploadDataSize));
1225   data_ir.set_fin(fin);
1226   return framer.SerializeData(data_ir);
1227 }
1228
1229 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
1230                                                 const char* data,
1231                                                 uint32 len,
1232                                                 bool fin) {
1233   SpdyFramer framer(spdy_version_);
1234   SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
1235   data_ir.set_fin(fin);
1236   return framer.SerializeData(data_ir);
1237 }
1238
1239 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
1240                                                 const char* data,
1241                                                 uint32 len,
1242                                                 bool fin,
1243                                                 int padding_length) {
1244   SpdyFramer framer(spdy_version_);
1245   SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
1246   data_ir.set_fin(fin);
1247   data_ir.set_padding_len(padding_length);
1248   return framer.SerializeData(data_ir);
1249 }
1250
1251 SpdyFrame* SpdyTestUtil::ConstructWrappedSpdyFrame(
1252     const scoped_ptr<SpdyFrame>& frame,
1253     int stream_id) {
1254   return ConstructSpdyBodyFrame(stream_id, frame->data(),
1255                                 frame->size(), false);
1256 }
1257
1258 const SpdyHeaderInfo SpdyTestUtil::MakeSpdyHeader(SpdyFrameType type) {
1259   const SpdyHeaderInfo kHeader = {
1260     type,
1261     1,                            // Stream ID
1262     0,                            // Associated stream ID
1263     ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_version_),
1264     kSpdyCredentialSlotUnused,
1265     CONTROL_FLAG_FIN,             // Control Flags
1266     false,                        // Compressed
1267     RST_STREAM_INVALID,
1268     NULL,                         // Data
1269     0,                            // Length
1270     DATA_FLAG_NONE
1271   };
1272   return kHeader;
1273 }
1274
1275 scoped_ptr<SpdyFramer> SpdyTestUtil::CreateFramer(bool compressed) const {
1276   scoped_ptr<SpdyFramer> framer(new SpdyFramer(spdy_version_));
1277   framer->set_enable_compression(compressed);
1278   return framer.Pass();
1279 }
1280
1281 const char* SpdyTestUtil::GetMethodKey() const {
1282   return ":method";
1283 }
1284
1285 const char* SpdyTestUtil::GetStatusKey() const {
1286   return ":status";
1287 }
1288
1289 const char* SpdyTestUtil::GetHostKey() const {
1290   if (protocol_ < kProtoHTTP2MinimumVersion)
1291     return ":host";
1292   else
1293     return ":authority";
1294 }
1295
1296 const char* SpdyTestUtil::GetSchemeKey() const {
1297   return ":scheme";
1298 }
1299
1300 const char* SpdyTestUtil::GetVersionKey() const {
1301   return ":version";
1302 }
1303
1304 const char* SpdyTestUtil::GetPathKey() const {
1305   return ":path";
1306 }
1307
1308 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeaderBlock(
1309     base::StringPiece method,
1310     base::StringPiece url,
1311     int64* content_length) const {
1312   std::string scheme, host, path;
1313   ParseUrl(url.data(), &scheme, &host, &path);
1314   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
1315   (*headers)[GetMethodKey()] = method.as_string();
1316   (*headers)[GetPathKey()] = path.c_str();
1317   (*headers)[GetHostKey()] = host.c_str();
1318   (*headers)[GetSchemeKey()] = scheme.c_str();
1319   if (include_version_header()) {
1320     (*headers)[GetVersionKey()] = "HTTP/1.1";
1321   }
1322   if (content_length) {
1323     std::string length_str = base::Int64ToString(*content_length);
1324     (*headers)["content-length"] = length_str;
1325   }
1326   return headers.Pass();
1327 }
1328
1329 void SpdyTestUtil::MaybeAddVersionHeader(
1330     SpdyFrameWithHeaderBlockIR* frame_ir) const {
1331   if (include_version_header()) {
1332     frame_ir->SetHeader(GetVersionKey(), "HTTP/1.1");
1333   }
1334 }
1335
1336 void SpdyTestUtil::MaybeAddVersionHeader(SpdyHeaderBlock* block) const {
1337   if (include_version_header()) {
1338     (*block)[GetVersionKey()] = "HTTP/1.1";
1339   }
1340 }
1341
1342 void SpdyTestUtil::SetPriority(RequestPriority priority,
1343                                SpdySynStreamIR* ir) const {
1344   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
1345       priority, spdy_version()));
1346 }
1347
1348 }  // namespace net