net/spdy/spdy_test_util_spdy2.cc

   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_test_util_spdy2.h"
   6
   7 #include <string>
   8
   9 #include "base/basictypes.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/string_number_conversions.h"
  12 #include "base/string_util.h"
  13 #include "net/cert/mock_cert_verifier.h"
  14 #include "net/http/http_network_session.h"
  15 #include "net/http/http_network_transaction.h"
  16 #include "net/http/http_server_properties_impl.h"
  17 #include "net/spdy/buffered_spdy_framer.h"
  18 #include "net/spdy/spdy_http_utils.h"
  19 #include "net/spdy/spdy_session.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace net {
  23 namespace test_spdy2 {
  24
  25 namespace {
  26
  27 // Parses a URL into the scheme, host, and path components required for a
  28 // SPDY request.
  29 void ParseUrl(const char* const url, std::string* scheme, std::string* host,
  30               std::string* path) {
  31   GURL gurl(url);
  32   path->assign(gurl.PathForRequest());
  33   scheme->assign(gurl.scheme());
  34   host->assign(gurl.host());
  35   if (gurl.has_port()) {
  36     host->append(":");
  37     host->append(gurl.port());
  38   }
  39 }
  40
  41 }  // namespace
  42
  43 scoped_ptr<SpdyHeaderBlock> ConstructGetHeaderBlock(base::StringPiece url) {
  44   std::string scheme, host, path;
  45   ParseUrl(url.data(), &scheme, &host, &path);
  46   const char* const headers[] = {
  47     "method",  "GET",
  48     "url",     path.c_str(),
  49     "host",    host.c_str(),
  50     "scheme",  scheme.c_str(),
  51     "version", "HTTP/1.1"
  52   };
  53   scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
  54   AppendToHeaderBlock(headers, arraysize(headers) / 2, header_block.get());
  55   return header_block.Pass();
  56 }
  57
  58 scoped_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(base::StringPiece url,
  59                                                      int64 content_length) {
  60   std::string scheme, host, path;
  61   ParseUrl(url.data(), &scheme, &host, &path);
  62   std::string length_str = base::Int64ToString(content_length);
  63   const char* const headers[] = {
  64     "method",  "POST",
  65     "url",     path.c_str(),
  66     "host",    host.c_str(),
  67     "scheme",  scheme.c_str(),
  68     "version", "HTTP/1.1",
  69     "content-length", length_str.c_str()
  70   };
  71   scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
  72   AppendToHeaderBlock(headers, arraysize(headers) / 2, header_block.get());
  73   return header_block.Pass();
  74 }
  75
  76 SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
  77                               scoped_ptr<SpdyHeaderBlock> headers) {
  78   BufferedSpdyFramer framer(kSpdyVersion2, header_info.compressed);
  79   SpdyFrame* frame = NULL;
  80   switch (header_info.kind) {
  81     case DATA:
  82       frame = framer.CreateDataFrame(header_info.id, header_info.data,
  83                                      header_info.data_length,
  84                                      header_info.data_flags);
  85       break;
  86     case SYN_STREAM:
  87       frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
  88                                      header_info.priority, 0,
  89                                      header_info.control_flags,
  90                                      header_info.compressed, headers.get());
  91       break;
  92     case SYN_REPLY:
  93       frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
  94                                     header_info.compressed, headers.get());
  95       break;
  96     case RST_STREAM:
  97       frame = framer.CreateRstStream(header_info.id, header_info.status);
  98       break;
  99     case HEADERS:
 100       frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
 101                                    header_info.compressed, headers.get());
 102       break;
 103     default:
 104       ADD_FAILURE();
 105       break;
 106   }
 107   return frame;
 108 }
 109
 110 SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
 111                               const char* const extra_headers[],
 112                               int extra_header_count,
 113                               const char* const tail[],
 114                               int tail_header_count) {
 115   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
 116   AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
 117   if (tail && tail_header_count)
 118     AppendToHeaderBlock(tail, tail_header_count, headers.get());
 119   return ConstructSpdyFrame(header_info, headers.Pass());
 120 }
 121
 122 SpdyFrame* ConstructSpdySettings(const SettingsMap& settings) {
 123   BufferedSpdyFramer framer(2, false);
 124   return framer.CreateSettings(settings);
 125 }
 126
 127 SpdyFrame* ConstructSpdyCredential(
 128     const SpdyCredential& credential) {
 129   BufferedSpdyFramer framer(2, false);
 130   return framer.CreateCredentialFrame(credential);
 131 }
 132
 133 SpdyFrame* ConstructSpdyPing(uint32 ping_id) {
 134   BufferedSpdyFramer framer(2, false);
 135   return framer.CreatePingFrame(ping_id);
 136 }
 137
 138 SpdyFrame* ConstructSpdyGoAway() {
 139   return ConstructSpdyGoAway(0);
 140 }
 141
 142 SpdyFrame* ConstructSpdyGoAway(SpdyStreamId last_good_stream_id) {
 143   BufferedSpdyFramer framer(2, false);
 144   return framer.CreateGoAway(last_good_stream_id, GOAWAY_OK);
 145 }
 146
 147 SpdyFrame* ConstructSpdyWindowUpdate(
 148     const SpdyStreamId stream_id, uint32 delta_window_size) {
 149   BufferedSpdyFramer framer(2, false);
 150   return framer.CreateWindowUpdate(stream_id, delta_window_size);
 151 }
 152
 153 SpdyFrame* ConstructSpdyRstStream(SpdyStreamId stream_id,
 154                                   SpdyRstStreamStatus status) {
 155   BufferedSpdyFramer framer(2, false);
 156   return framer.CreateRstStream(stream_id, status);
 157 }
 158
 159 int ConstructSpdyHeader(const char* const extra_headers[],
 160                         int extra_header_count,
 161                         char* buffer,
 162                         int buffer_length,
 163                         int index) {
 164   const char* this_header = NULL;
 165   const char* this_value = NULL;
 166   if (!buffer || !buffer_length)
 167     return 0;
 168   *buffer = '\0';
 169   // Sanity check: Non-empty header list.
 170   DCHECK(NULL != extra_headers) << "NULL extra headers pointer";
 171   // Sanity check: Index out of range.
 172   DCHECK((index >= 0) && (index < extra_header_count))
 173       << "Index " << index
 174       << " out of range [0, " << extra_header_count << ")";
 175   this_header = extra_headers[index * 2];
 176   // Sanity check: Non-empty header.
 177   if (!*this_header)
 178     return 0;
 179   std::string::size_type header_len = strlen(this_header);
 180   if (!header_len)
 181     return 0;
 182   this_value = extra_headers[1 + (index * 2)];
 183   // Sanity check: Non-empty value.
 184   if (!*this_value)
 185     this_value = "";
 186   int n = base::snprintf(buffer,
 187                          buffer_length,
 188                          "%s: %s\r\n",
 189                          this_header,
 190                          this_value);
 191   return n;
 192 }
 193
 194 SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
 195                                      int extra_header_count,
 196                                      bool compressed,
 197                                      int stream_id,
 198                                      RequestPriority request_priority,
 199                                      SpdyFrameType type,
 200                                      SpdyControlFlags flags,
 201                                      const char* const* kHeaders,
 202                                      int kHeadersSize) {
 203   EXPECT_GE(type, FIRST_CONTROL_TYPE);
 204   EXPECT_LE(type, LAST_CONTROL_TYPE);
 205   return ConstructSpdyControlFrame(extra_headers,
 206                                    extra_header_count,
 207                                    compressed,
 208                                    stream_id,
 209                                    request_priority,
 210                                    type,
 211                                    flags,
 212                                    kHeaders,
 213                                    kHeadersSize,
 214                                    0);
 215 }
 216
 217 SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
 218                                      int extra_header_count,
 219                                      bool compressed,
 220                                      SpdyStreamId stream_id,
 221                                      RequestPriority request_priority,
 222                                      SpdyFrameType type,
 223                                      SpdyControlFlags flags,
 224                                      const char* const* kHeaders,
 225                                      int kHeadersSize,
 226                                      SpdyStreamId associated_stream_id) {
 227   EXPECT_GE(type, FIRST_CONTROL_TYPE);
 228   EXPECT_LE(type, LAST_CONTROL_TYPE);
 229   const SpdyHeaderInfo kSynStartHeader = {
 230     type,                         // Kind = Syn
 231     stream_id,                    // Stream ID
 232     associated_stream_id,         // Associated stream ID
 233     ConvertRequestPriorityToSpdyPriority(request_priority, 2),
 234                                   // Priority
 235     kSpdyCredentialSlotUnused,
 236     flags,                        // Control Flags
 237     compressed,                   // Compressed
 238     RST_STREAM_INVALID,           // Status
 239     NULL,                         // Data
 240     0,                            // Length
 241     DATA_FLAG_NONE                // Data Flags
 242   };
 243   return ConstructSpdyFrame(kSynStartHeader,
 244                             extra_headers,
 245                             extra_header_count,
 246                             kHeaders,
 247                             kHeadersSize / 2);
 248 }
 249
 250 SpdyFrame* ConstructSpdyGet(const char* const url,
 251                             bool compressed,
 252                             SpdyStreamId stream_id,
 253                             RequestPriority request_priority) {
 254   const SpdyHeaderInfo kSynStartHeader = {
 255     SYN_STREAM,             // Kind = Syn
 256     stream_id,              // Stream ID
 257     0,                      // Associated stream ID
 258     ConvertRequestPriorityToSpdyPriority(request_priority, 2),
 259                             // Priority
 260     kSpdyCredentialSlotUnused,
 261     CONTROL_FLAG_FIN,       // Control Flags
 262     compressed,             // Compressed
 263     RST_STREAM_INVALID,     // Status
 264     NULL,                   // Data
 265     0,                      // Length
 266     DATA_FLAG_NONE          // Data Flags
 267   };
 268   return ConstructSpdyFrame(kSynStartHeader, ConstructGetHeaderBlock(url));
 269 }
 270
 271 SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
 272                             int extra_header_count,
 273                             bool compressed,
 274                             int stream_id,
 275                             RequestPriority request_priority) {
 276   return ConstructSpdyGet(extra_headers, extra_header_count, compressed,
 277                           stream_id, request_priority, true);
 278 }
 279
 280 SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
 281                             int extra_header_count,
 282                             bool compressed,
 283                             int stream_id,
 284                             RequestPriority request_priority,
 285                             bool direct) {
 286   const char* const kStandardGetHeaders[] = {
 287     "method", "GET",
 288     "url", (direct ? "/" : "http://www.google.com/"),
 289     "host", "www.google.com",
 290     "scheme", "http",
 291     "version", "HTTP/1.1"
 292   };
 293   return ConstructSpdyControlFrame(extra_headers,
 294                                    extra_header_count,
 295                                    compressed,
 296                                    stream_id,
 297                                    request_priority,
 298                                    SYN_STREAM,
 299                                    CONTROL_FLAG_FIN,
 300                                    kStandardGetHeaders,
 301                                    arraysize(kStandardGetHeaders));
 302 }
 303
 304 SpdyFrame* ConstructSpdyConnect(const char* const extra_headers[],
 305                                 int extra_header_count,
 306                                 int stream_id) {
 307   const char* const kConnectHeaders[] = {
 308     "method", "CONNECT",
 309     "url", "www.google.com:443",
 310     "host", "www.google.com",
 311     "version", "HTTP/1.1",
 312   };
 313   return ConstructSpdyControlFrame(extra_headers,
 314                                    extra_header_count,
 315                                    /*compressed*/ false,
 316                                    stream_id,
 317                                    LOWEST,
 318                                    SYN_STREAM,
 319                                    CONTROL_FLAG_NONE,
 320                                    kConnectHeaders,
 321                                    arraysize(kConnectHeaders));
 322 }
 323
 324 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
 325                              int extra_header_count,
 326                              int stream_id,
 327                              int associated_stream_id) {
 328   const char* const kStandardGetHeaders[] = {
 329     "hello", "bye",
 330     "status", "200",
 331     "version", "HTTP/1.1"
 332   };
 333   return ConstructSpdyControlFrame(extra_headers,
 334                                    extra_header_count,
 335                                    false,
 336                                    stream_id,
 337                                    LOWEST,
 338                                    SYN_STREAM,
 339                                    CONTROL_FLAG_NONE,
 340                                    kStandardGetHeaders,
 341                                    arraysize(kStandardGetHeaders),
 342                                    associated_stream_id);
 343 }
 344
 345 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
 346                              int extra_header_count,
 347                              int stream_id,
 348                              int associated_stream_id,
 349                              const char* url) {
 350   const char* const kStandardGetHeaders[] = {
 351     "hello", "bye",
 352     "status", "200 OK",
 353     "url", url,
 354     "version", "HTTP/1.1"
 355   };
 356   return ConstructSpdyControlFrame(extra_headers,
 357                                    extra_header_count,
 358                                    false,
 359                                    stream_id,
 360                                    LOWEST,
 361                                    SYN_STREAM,
 362                                    CONTROL_FLAG_NONE,
 363                                    kStandardGetHeaders,
 364                                    arraysize(kStandardGetHeaders),
 365                                    associated_stream_id);
 366
 367 }
 368 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
 369                              int extra_header_count,
 370                              int stream_id,
 371                              int associated_stream_id,
 372                              const char* url,
 373                              const char* status,
 374                              const char* location) {
 375   const char* const kStandardGetHeaders[] = {
 376     "hello", "bye",
 377     "status",  status,
 378     "location", location,
 379     "url", url,
 380     "version", "HTTP/1.1"
 381   };
 382   return ConstructSpdyControlFrame(extra_headers,
 383                                    extra_header_count,
 384                                    false,
 385                                    stream_id,
 386                                    LOWEST,
 387                                    SYN_STREAM,
 388                                    CONTROL_FLAG_NONE,
 389                                    kStandardGetHeaders,
 390                                    arraysize(kStandardGetHeaders),
 391                                    associated_stream_id);
 392 }
 393
 394 SpdyFrame* ConstructSpdyPush(int stream_id,
 395                              int associated_stream_id,
 396                              const char* url) {
 397   const char* const kStandardGetHeaders[] = {
 398     "url", url
 399   };
 400   return ConstructSpdyControlFrame(0,
 401                                    0,
 402                                    false,
 403                                    stream_id,
 404                                    LOWEST,
 405                                    SYN_STREAM,
 406                                    CONTROL_FLAG_NONE,
 407                                    kStandardGetHeaders,
 408                                    arraysize(kStandardGetHeaders),
 409                                    associated_stream_id);
 410 }
 411
 412 SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
 413                                     const char* const extra_headers[],
 414                                     int extra_header_count) {
 415   const char* const kStandardGetHeaders[] = {
 416     "status", "200 OK",
 417     "version", "HTTP/1.1"
 418   };
 419   return ConstructSpdyControlFrame(extra_headers,
 420                                    extra_header_count,
 421                                    false,
 422                                    stream_id,
 423                                    LOWEST,
 424                                    HEADERS,
 425                                    CONTROL_FLAG_NONE,
 426                                    kStandardGetHeaders,
 427                                    arraysize(kStandardGetHeaders));
 428 }
 429
 430 SpdyFrame* ConstructSpdySynReplyError(const char* const status,
 431                                       const char* const* const extra_headers,
 432                                       int extra_header_count,
 433                                       int stream_id) {
 434   const char* const kStandardGetHeaders[] = {
 435     "hello", "bye",
 436     "status", status,
 437     "version", "HTTP/1.1"
 438   };
 439   return ConstructSpdyControlFrame(extra_headers,
 440                                    extra_header_count,
 441                                    false,
 442                                    stream_id,
 443                                    LOWEST,
 444                                    SYN_REPLY,
 445                                    CONTROL_FLAG_NONE,
 446                                    kStandardGetHeaders,
 447                                    arraysize(kStandardGetHeaders));
 448 }
 449
 450 SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id) {
 451   static const char* const kExtraHeaders[] = {
 452     "location", "http://www.foo.com/index.php",
 453   };
 454   return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
 455                                     arraysize(kExtraHeaders)/2, stream_id);
 456 }
 457
 458 SpdyFrame* ConstructSpdySynReplyError(int stream_id) {
 459   return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
 460 }
 461
 462 SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
 463                                     int extra_header_count,
 464                                     int stream_id) {
 465   static const char* const kStandardGetHeaders[] = {
 466     "hello", "bye",
 467     "status", "200",
 468     "version", "HTTP/1.1"
 469   };
 470   return ConstructSpdyControlFrame(extra_headers,
 471                                    extra_header_count,
 472                                    false,
 473                                    stream_id,
 474                                    LOWEST,
 475                                    SYN_REPLY,
 476                                    CONTROL_FLAG_NONE,
 477                                    kStandardGetHeaders,
 478                                    arraysize(kStandardGetHeaders));
 479 }
 480
 481 SpdyFrame* ConstructSpdyPost(const char* url,
 482                              int64 content_length,
 483                              const char* const extra_headers[],
 484                              int extra_header_count) {
 485   const SpdyHeaderInfo kSynStartHeader = {
 486     SYN_STREAM,             // Kind = Syn
 487     1,                      // Stream ID
 488     0,                      // Associated stream ID
 489     ConvertRequestPriorityToSpdyPriority(LOWEST, 2),
 490                             // Priority
 491     kSpdyCredentialSlotUnused,
 492     CONTROL_FLAG_NONE,      // Control Flags
 493     false,                  // Compressed
 494     RST_STREAM_INVALID,     // Status
 495     NULL,                   // Data
 496     0,                      // Length
 497     DATA_FLAG_NONE          // Data Flags
 498   };
 499   return ConstructSpdyFrame(
 500       kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
 501 }
 502
 503 SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
 504                                     int extra_header_count) {
 505   const char* post_headers[] = {
 506     "method", "POST",
 507     "url", "/",
 508     "host", "www.google.com",
 509     "scheme", "http",
 510     "version", "HTTP/1.1"
 511   };
 512   return ConstructSpdyControlFrame(extra_headers,
 513                                    extra_header_count,
 514                                    false,
 515                                    1,
 516                                    LOWEST,
 517                                    SYN_STREAM,
 518                                    CONTROL_FLAG_NONE,
 519                                    post_headers,
 520                                    arraysize(post_headers));
 521 }
 522
 523 SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
 524                                      int extra_header_count) {
 525   static const char* const kStandardGetHeaders[] = {
 526     "hello", "bye",
 527     "status", "200",
 528     "url", "/index.php",
 529     "version", "HTTP/1.1"
 530   };
 531   return ConstructSpdyControlFrame(extra_headers,
 532                                    extra_header_count,
 533                                    false,
 534                                    1,
 535                                    LOWEST,
 536                                    SYN_REPLY,
 537                                    CONTROL_FLAG_NONE,
 538                                    kStandardGetHeaders,
 539                                    arraysize(kStandardGetHeaders));
 540 }
 541
 542 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin) {
 543   BufferedSpdyFramer framer(2, false);
 544   return framer.CreateDataFrame(
 545       stream_id, kUploadData, kUploadDataSize,
 546       fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 547 }
 548
 549 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
 550                                   uint32 len, bool fin) {
 551   BufferedSpdyFramer framer(2, false);
 552   return framer.CreateDataFrame(
 553       stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 554 }
 555
 556 SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
 557                                      int stream_id) {
 558   return ConstructSpdyBodyFrame(stream_id, frame->data(),
 559                                 frame->size(), false);
 560 }
 561
 562 int ConstructSpdyReplyString(const char* const extra_headers[],
 563                              int extra_header_count,
 564                              char* buffer,
 565                              int buffer_length) {
 566   int frame_size = 0;
 567   char* buffer_write = buffer;
 568   int buffer_left = buffer_length;
 569   SpdyHeaderBlock headers;
 570   if (!buffer || !buffer_length)
 571     return 0;
 572   // Copy in the extra headers.
 573   AppendToHeaderBlock(extra_headers, extra_header_count, &headers);
 574   // The iterator gets us the list of header/value pairs in sorted order.
 575   SpdyHeaderBlock::iterator next = headers.begin();
 576   SpdyHeaderBlock::iterator last = headers.end();
 577   for ( ; next != last; ++next) {
 578     // Write the header.
 579     int value_len, current_len, offset;
 580     const char* header_string = next->first.c_str();
 581     frame_size += AppendToBuffer(header_string,
 582                                  next->first.length(),
 583                                  &buffer_write,
 584                                  &buffer_left);
 585     frame_size += AppendToBuffer(": ",
 586                                  strlen(": "),
 587                                  &buffer_write,
 588                                  &buffer_left);
 589     // Write the value(s).
 590     const char* value_string = next->second.c_str();
 591     // Check if it's split among two or more values.
 592     value_len = next->second.length();
 593     current_len = strlen(value_string);
 594     offset = 0;
 595     // Handle the first N-1 values.
 596     while (current_len < value_len) {
 597       // Finish this line -- write the current value.
 598       frame_size += AppendToBuffer(value_string + offset,
 599                                    current_len - offset,
 600                                    &buffer_write,
 601                                    &buffer_left);
 602       frame_size += AppendToBuffer("\n",
 603                                    strlen("\n"),
 604                                    &buffer_write,
 605                                    &buffer_left);
 606       // Advance to next value.
 607       offset = current_len + 1;
 608       current_len += 1 + strlen(value_string + offset);
 609       // Start another line -- add the header again.
 610       frame_size += AppendToBuffer(header_string,
 611                                    next->first.length(),
 612                                    &buffer_write,
 613                                    &buffer_left);
 614       frame_size += AppendToBuffer(": ",
 615                                    strlen(": "),
 616                                    &buffer_write,
 617                                    &buffer_left);
 618     }
 619     EXPECT_EQ(value_len, current_len);
 620     // Copy the last (or only) value.
 621     frame_size += AppendToBuffer(value_string + offset,
 622                                  value_len - offset,
 623                                  &buffer_write,
 624                                  &buffer_left);
 625     frame_size += AppendToBuffer("\n",
 626                                  strlen("\n"),
 627                                  &buffer_write,
 628                                  &buffer_left);
 629   }
 630   return frame_size;
 631 }
 632
 633 SpdySessionDependencies::SpdySessionDependencies()
 634     : host_resolver(new MockCachingHostResolver),
 635       cert_verifier(new MockCertVerifier),
 636       proxy_service(ProxyService::CreateDirect()),
 637       ssl_config_service(new SSLConfigServiceDefaults),
 638       socket_factory(new MockClientSocketFactory),
 639       deterministic_socket_factory(new DeterministicMockClientSocketFactory),
 640       http_auth_handler_factory(
 641           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
 642       enable_ip_pooling(true),
 643       enable_compression(false),
 644       enable_ping(false),
 645       enable_user_alternate_protocol_ports(false),
 646       time_func(&base::TimeTicks::Now),
 647       net_log(NULL) {
 648   // Note: The CancelledTransaction test does cleanup by running all
 649   // tasks in the message loop (RunAllPending).  Unfortunately, that
 650   // doesn't clean up tasks on the host resolver thread; and
 651   // TCPConnectJob is currently not cancellable.  Using synchronous
 652   // lookups allows the test to shutdown cleanly.  Until we have
 653   // cancellable TCPConnectJobs, use synchronous lookups.
 654   host_resolver->set_synchronous_mode(true);
 655 }
 656
 657 SpdySessionDependencies::SpdySessionDependencies(ProxyService* proxy_service)
 658     : host_resolver(new MockHostResolver),
 659       cert_verifier(new MockCertVerifier),
 660       proxy_service(proxy_service),
 661       ssl_config_service(new SSLConfigServiceDefaults),
 662       socket_factory(new MockClientSocketFactory),
 663       deterministic_socket_factory(new DeterministicMockClientSocketFactory),
 664       http_auth_handler_factory(
 665           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
 666       enable_ip_pooling(true),
 667       enable_compression(false),
 668       enable_ping(false),
 669       enable_user_alternate_protocol_ports(false),
 670       time_func(&base::TimeTicks::Now),
 671       net_log(NULL) {}
 672
 673 SpdySessionDependencies::~SpdySessionDependencies() {}
 674
 675 // static
 676 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSession(
 677     SpdySessionDependencies* session_deps) {
 678   net::HttpNetworkSession::Params params = CreateSessionParams(session_deps);
 679   params.client_socket_factory = session_deps->socket_factory.get();
 680   HttpNetworkSession* http_session = new HttpNetworkSession(params);
 681   SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
 682   pool_peer.EnableSendingInitialSettings(false);
 683   return http_session;
 684 }
 685
 686 // static
 687 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSessionDeterministic(
 688     SpdySessionDependencies* session_deps) {
 689   net::HttpNetworkSession::Params params = CreateSessionParams(session_deps);
 690   params.client_socket_factory =
 691       session_deps->deterministic_socket_factory.get();
 692   HttpNetworkSession* http_session = new HttpNetworkSession(params);
 693   SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
 694   pool_peer.EnableSendingInitialSettings(false);
 695   return http_session;
 696 }
 697
 698 // static
 699 net::HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
 700     SpdySessionDependencies* session_deps) {
 701   net::HttpNetworkSession::Params params;
 702   params.host_resolver = session_deps->host_resolver.get();
 703   params.cert_verifier = session_deps->cert_verifier.get();
 704   params.proxy_service = session_deps->proxy_service.get();
 705   params.ssl_config_service = session_deps->ssl_config_service;
 706   params.http_auth_handler_factory =
 707       session_deps->http_auth_handler_factory.get();
 708   params.http_server_properties = &session_deps->http_server_properties;
 709   params.enable_spdy_ip_pooling = session_deps->enable_ip_pooling;
 710   params.enable_spdy_compression = session_deps->enable_compression;
 711   params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
 712   params.enable_user_alternate_protocol_ports =
 713       session_deps->enable_user_alternate_protocol_ports;
 714   params.spdy_default_protocol = kProtoSPDY2;
 715   params.time_func = session_deps->time_func;
 716   params.trusted_spdy_proxy = session_deps->trusted_spdy_proxy;
 717   params.net_log = session_deps->net_log;
 718   return params;
 719 }
 720
 721 SpdyURLRequestContext::SpdyURLRequestContext()
 722     : ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) {
 723   storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver));
 724   storage_.set_cert_verifier(new MockCertVerifier);
 725   storage_.set_proxy_service(ProxyService::CreateDirect());
 726   storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
 727   storage_.set_http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault(
 728       host_resolver()));
 729   storage_.set_http_server_properties(new HttpServerPropertiesImpl);
 730   net::HttpNetworkSession::Params params;
 731   params.client_socket_factory = &socket_factory_;
 732   params.host_resolver = host_resolver();
 733   params.cert_verifier = cert_verifier();
 734   params.proxy_service = proxy_service();
 735   params.ssl_config_service = ssl_config_service();
 736   params.http_auth_handler_factory = http_auth_handler_factory();
 737   params.network_delegate = network_delegate();
 738   params.enable_spdy_compression = false;
 739   params.enable_spdy_ping_based_connection_checking = false;
 740   params.spdy_default_protocol = kProtoSPDY2;
 741   params.http_server_properties = http_server_properties();
 742   scoped_refptr<HttpNetworkSession> network_session(
 743       new HttpNetworkSession(params));
 744   SpdySessionPoolPeer pool_peer(network_session->spdy_session_pool());
 745   pool_peer.EnableSendingInitialSettings(false);
 746   storage_.set_http_transaction_factory(new HttpCache(
 747       network_session,
 748       HttpCache::DefaultBackend::InMemory(0)));
 749 }
 750
 751 SpdyURLRequestContext::~SpdyURLRequestContext() {
 752 }
 753
 754 const SpdyHeaderInfo MakeSpdyHeader(SpdyFrameType type) {
 755   const SpdyHeaderInfo kHeader = {
 756     type,                         // Kind = Syn
 757     1,                            // Stream ID
 758     0,                            // Associated stream ID
 759     ConvertRequestPriorityToSpdyPriority(LOWEST, 2),  // Priority
 760     kSpdyCredentialSlotUnused,
 761     CONTROL_FLAG_FIN,       // Control Flags
 762     false,                        // Compressed
 763     RST_STREAM_INVALID,           // Status
 764     NULL,                         // Data
 765     0,                            // Length
 766     DATA_FLAG_NONE          // Data Flags
 767   };
 768   return kHeader;
 769 }
 770
 771 }  // namespace test_spdy2
 772 }  // namespace net