src/net/http/http_response_headers_unittest.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 <algorithm>
   6 #include <iostream>
   7 #include <limits>
   8
   9 #include "base/basictypes.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/pickle.h"
  12 #include "base/time/time.h"
  13 #include "base/values.h"
  14 #include "net/http/http_byte_range.h"
  15 #include "net/http/http_response_headers.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace {
  19
  20 struct TestData {
  21   const char* raw_headers;
  22   const char* expected_headers;
  23   int expected_response_code;
  24   net::HttpVersion expected_parsed_version;
  25   net::HttpVersion expected_version;
  26 };
  27
  28 class HttpResponseHeadersTest : public testing::Test {
  29 };
  30
  31 // Transform "normal"-looking headers (\n-separated) to the appropriate
  32 // input format for ParseRawHeaders (\0-separated).
  33 void HeadersToRaw(std::string* headers) {
  34   std::replace(headers->begin(), headers->end(), '\n', '\0');
  35   if (!headers->empty())
  36     *headers += '\0';
  37 }
  38
  39 class HttpResponseHeadersCacheControlTest : public HttpResponseHeadersTest {
  40  protected:
  41   // Make tests less verbose.
  42   typedef base::TimeDelta TimeDelta;
  43
  44   // Initilise the headers() value with a Cache-Control header set to
  45   // |cache_control|. |cache_control| is copied and so can safely be a
  46   // temporary.
  47   void InitializeHeadersWithCacheControl(const char* cache_control) {
  48     std::string raw_headers("HTTP/1.1 200 OK\n");
  49     raw_headers += "Cache-Control: ";
  50     raw_headers += cache_control;
  51     raw_headers += "\n";
  52     HeadersToRaw(&raw_headers);
  53     headers_ = new net::HttpResponseHeaders(raw_headers);
  54   }
  55
  56   const scoped_refptr<net::HttpResponseHeaders>& headers() { return headers_; }
  57
  58   // Return a pointer to a TimeDelta object. For use when the value doesn't
  59   // matter.
  60   TimeDelta* TimeDeltaPointer() { return &delta_; }
  61
  62   // Get the max-age value. This should only be used in tests where a valid
  63   // max-age parameter is expected to be present.
  64   TimeDelta GetMaxAgeValue() {
  65     DCHECK(headers_.get()) << "Call InitializeHeadersWithCacheControl() first";
  66     TimeDelta max_age_value;
  67     EXPECT_TRUE(headers()->GetMaxAgeValue(&max_age_value));
  68     return max_age_value;
  69   }
  70
  71   // Get the stale-while-revalidate value. This should only be used in tests
  72   // where a valid max-age parameter is expected to be present.
  73   TimeDelta GetStaleWhileRevalidateValue() {
  74     DCHECK(headers_.get()) << "Call InitializeHeadersWithCacheControl() first";
  75     TimeDelta stale_while_revalidate_value;
  76     EXPECT_TRUE(
  77         headers()->GetStaleWhileRevalidateValue(&stale_while_revalidate_value));
  78     return stale_while_revalidate_value;
  79   }
  80
  81  private:
  82   scoped_refptr<net::HttpResponseHeaders> headers_;
  83   TimeDelta delta_;
  84 };
  85
  86 class CommonHttpResponseHeadersTest
  87     : public HttpResponseHeadersTest,
  88       public ::testing::WithParamInterface<TestData> {
  89 };
  90
  91 TEST_P(CommonHttpResponseHeadersTest, TestCommon) {
  92   const TestData test = GetParam();
  93
  94   std::string raw_headers(test.raw_headers);
  95   HeadersToRaw(&raw_headers);
  96   std::string expected_headers(test.expected_headers);
  97
  98   std::string headers;
  99   scoped_refptr<net::HttpResponseHeaders> parsed(
 100       new net::HttpResponseHeaders(raw_headers));
 101   parsed->GetNormalizedHeaders(&headers);
 102
 103   // Transform to readable output format (so it's easier to see diffs).
 104   std::replace(headers.begin(), headers.end(), ' ', '_');
 105   std::replace(headers.begin(), headers.end(), '\n', '\\');
 106   std::replace(expected_headers.begin(), expected_headers.end(), ' ', '_');
 107   std::replace(expected_headers.begin(), expected_headers.end(), '\n', '\\');
 108
 109   EXPECT_EQ(expected_headers, headers);
 110
 111   EXPECT_EQ(test.expected_response_code, parsed->response_code());
 112
 113   EXPECT_TRUE(test.expected_parsed_version == parsed->GetParsedHttpVersion());
 114   EXPECT_TRUE(test.expected_version == parsed->GetHttpVersion());
 115 }
 116
 117 TestData response_headers_tests[] = {
 118   {
 119     // Normalise whitespace.
 120
 121     "HTTP/1.1    202   Accepted  \n"
 122     "Content-TYPE  : text/html; charset=utf-8  \n"
 123     "Set-Cookie: a \n"
 124     "Set-Cookie:   b \n",
 125
 126     "HTTP/1.1 202 Accepted\n"
 127     "Content-TYPE: text/html; charset=utf-8\n"
 128     "Set-Cookie: a, b\n",
 129
 130     202,
 131     net::HttpVersion(1,1),
 132     net::HttpVersion(1,1)
 133   },
 134   {
 135     // Normalize leading whitespace.
 136
 137     "HTTP/1.1    202   Accepted  \n"
 138     // Starts with space -- will be skipped as invalid.
 139     "  Content-TYPE  : text/html; charset=utf-8  \n"
 140     "Set-Cookie: a \n"
 141     "Set-Cookie:   b \n",
 142
 143     "HTTP/1.1 202 Accepted\n"
 144     "Set-Cookie: a, b\n",
 145
 146     202,
 147     net::HttpVersion(1,1),
 148     net::HttpVersion(1,1)
 149   },
 150   {
 151     // Normalize blank headers.
 152
 153     "HTTP/1.1 200 OK\n"
 154     "Header1 :          \n"
 155     "Header2: \n"
 156     "Header3:\n"
 157     "Header4\n"
 158     "Header5    :\n",
 159
 160     "HTTP/1.1 200 OK\n"
 161     "Header1: \n"
 162     "Header2: \n"
 163     "Header3: \n"
 164     "Header5: \n",
 165
 166     200,
 167     net::HttpVersion(1,1),
 168     net::HttpVersion(1,1)
 169   },
 170   {
 171     // Don't believe the http/0.9 version if there are headers!
 172
 173     "hTtP/0.9 201\n"
 174     "Content-TYPE: text/html; charset=utf-8\n",
 175
 176     "HTTP/1.0 201 OK\n"
 177     "Content-TYPE: text/html; charset=utf-8\n",
 178
 179     201,
 180     net::HttpVersion(0,9),
 181     net::HttpVersion(1,0)
 182   },
 183   {
 184     // Accept the HTTP/0.9 version number if there are no headers.
 185     // This is how HTTP/0.9 responses get constructed from
 186     // HttpNetworkTransaction.
 187
 188     "hTtP/0.9 200 OK\n",
 189
 190     "HTTP/0.9 200 OK\n",
 191
 192     200,
 193     net::HttpVersion(0,9),
 194     net::HttpVersion(0,9)
 195   },
 196   {
 197     // Add missing OK.
 198
 199     "HTTP/1.1 201\n"
 200     "Content-TYPE: text/html; charset=utf-8\n",
 201
 202     "HTTP/1.1 201 OK\n"
 203     "Content-TYPE: text/html; charset=utf-8\n",
 204
 205     201,
 206     net::HttpVersion(1,1),
 207     net::HttpVersion(1,1)
 208   },
 209   {
 210     // Normalize bad status line.
 211
 212     "SCREWED_UP_STATUS_LINE\n"
 213     "Content-TYPE: text/html; charset=utf-8\n",
 214
 215     "HTTP/1.0 200 OK\n"
 216     "Content-TYPE: text/html; charset=utf-8\n",
 217
 218     200,
 219     net::HttpVersion(0,0), // Parse error.
 220     net::HttpVersion(1,0)
 221   },
 222   {
 223     // Normalize invalid status code.
 224
 225     "HTTP/1.1 -1  Unknown\n",
 226
 227     "HTTP/1.1 200 OK\n",
 228
 229     200,
 230     net::HttpVersion(1,1),
 231     net::HttpVersion(1,1)
 232   },
 233   {
 234     // Normalize empty header.
 235
 236     "",
 237
 238     "HTTP/1.0 200 OK\n",
 239
 240     200,
 241     net::HttpVersion(0,0), // Parse Error.
 242     net::HttpVersion(1,0)
 243   },
 244   {
 245     // Normalize headers that start with a colon.
 246
 247     "HTTP/1.1    202   Accepted  \n"
 248     "foo: bar\n"
 249     ": a \n"
 250     " : b\n"
 251     "baz: blat \n",
 252
 253     "HTTP/1.1 202 Accepted\n"
 254     "foo: bar\n"
 255     "baz: blat\n",
 256
 257     202,
 258     net::HttpVersion(1,1),
 259     net::HttpVersion(1,1)
 260   },
 261   {
 262     // Normalize headers that end with a colon.
 263
 264     "HTTP/1.1    202   Accepted  \n"
 265     "foo:   \n"
 266     "bar:\n"
 267     "baz: blat \n"
 268     "zip:\n",
 269
 270     "HTTP/1.1 202 Accepted\n"
 271     "foo: \n"
 272     "bar: \n"
 273     "baz: blat\n"
 274     "zip: \n",
 275
 276     202,
 277     net::HttpVersion(1,1),
 278     net::HttpVersion(1,1)
 279   },
 280   {
 281     // Normalize whitespace headers.
 282
 283     "\n   \n",
 284
 285     "HTTP/1.0 200 OK\n",
 286
 287     200,
 288     net::HttpVersion(0,0),  // Parse error.
 289     net::HttpVersion(1,0)
 290   },
 291   {
 292     // Consolidate Set-Cookie headers.
 293
 294     "HTTP/1.1 200 OK\n"
 295     "Set-Cookie: x=1\n"
 296     "Set-Cookie: y=2\n",
 297
 298     "HTTP/1.1 200 OK\n"
 299     "Set-Cookie: x=1, y=2\n",
 300
 301     200,
 302     net::HttpVersion(1,1),
 303     net::HttpVersion(1,1)
 304   },
 305 };
 306
 307 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
 308                         CommonHttpResponseHeadersTest,
 309                         testing::ValuesIn(response_headers_tests));
 310
 311 TEST(HttpResponseHeadersTest, GetNormalizedHeader) {
 312   std::string headers =
 313       "HTTP/1.1 200 OK\n"
 314       "Cache-control: private\n"
 315       "cache-Control: no-store\n";
 316   HeadersToRaw(&headers);
 317   scoped_refptr<net::HttpResponseHeaders> parsed(
 318       new net::HttpResponseHeaders(headers));
 319
 320   std::string value;
 321   EXPECT_TRUE(parsed->GetNormalizedHeader("cache-control", &value));
 322   EXPECT_EQ("private, no-store", value);
 323 }
 324
 325 struct PersistData {
 326   net::HttpResponseHeaders::PersistOptions options;
 327   const char* raw_headers;
 328   const char* expected_headers;
 329 };
 330
 331 class PersistenceTest
 332     : public HttpResponseHeadersTest,
 333       public ::testing::WithParamInterface<PersistData> {
 334 };
 335
 336 TEST_P(PersistenceTest, Persist) {
 337   const PersistData test = GetParam();
 338
 339   std::string headers = test.raw_headers;
 340   HeadersToRaw(&headers);
 341   scoped_refptr<net::HttpResponseHeaders> parsed1(
 342       new net::HttpResponseHeaders(headers));
 343
 344   Pickle pickle;
 345   parsed1->Persist(&pickle, test.options);
 346
 347   PickleIterator iter(pickle);
 348   scoped_refptr<net::HttpResponseHeaders> parsed2(
 349       new net::HttpResponseHeaders(pickle, &iter));
 350
 351   std::string h2;
 352   parsed2->GetNormalizedHeaders(&h2);
 353   EXPECT_EQ(std::string(test.expected_headers), h2);
 354 }
 355
 356 const struct PersistData persistence_tests[] = {
 357   { net::HttpResponseHeaders::PERSIST_ALL,
 358     "HTTP/1.1 200 OK\n"
 359     "Cache-control:private\n"
 360     "cache-Control:no-store\n",
 361
 362     "HTTP/1.1 200 OK\n"
 363     "Cache-control: private, no-store\n"
 364   },
 365   { net::HttpResponseHeaders::PERSIST_SANS_HOP_BY_HOP,
 366     "HTTP/1.1 200 OK\n"
 367     "connection: keep-alive\n"
 368     "server: blah\n",
 369
 370     "HTTP/1.1 200 OK\n"
 371     "server: blah\n"
 372   },
 373   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE |
 374     net::HttpResponseHeaders::PERSIST_SANS_HOP_BY_HOP,
 375     "HTTP/1.1 200 OK\n"
 376     "fOo: 1\n"
 377     "Foo: 2\n"
 378     "Transfer-Encoding: chunked\n"
 379     "CoNnection: keep-alive\n"
 380     "cache-control: private, no-cache=\"foo\"\n",
 381
 382     "HTTP/1.1 200 OK\n"
 383     "cache-control: private, no-cache=\"foo\"\n"
 384   },
 385   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE,
 386     "HTTP/1.1 200 OK\n"
 387     "Foo: 2\n"
 388     "Cache-Control: private,no-cache=\"foo, bar\"\n"
 389     "bar",
 390
 391     "HTTP/1.1 200 OK\n"
 392     "Cache-Control: private,no-cache=\"foo, bar\"\n"
 393   },
 394   // Ignore bogus no-cache value.
 395   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE,
 396     "HTTP/1.1 200 OK\n"
 397     "Foo: 2\n"
 398     "Cache-Control: private,no-cache=foo\n",
 399
 400     "HTTP/1.1 200 OK\n"
 401     "Foo: 2\n"
 402     "Cache-Control: private,no-cache=foo\n"
 403   },
 404   // Ignore bogus no-cache value.
 405   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE,
 406     "HTTP/1.1 200 OK\n"
 407     "Foo: 2\n"
 408     "Cache-Control: private, no-cache=\n",
 409
 410     "HTTP/1.1 200 OK\n"
 411     "Foo: 2\n"
 412     "Cache-Control: private, no-cache=\n"
 413   },
 414   // Ignore empty no-cache value.
 415   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE,
 416     "HTTP/1.1 200 OK\n"
 417     "Foo: 2\n"
 418     "Cache-Control: private, no-cache=\"\"\n",
 419
 420     "HTTP/1.1 200 OK\n"
 421     "Foo: 2\n"
 422     "Cache-Control: private, no-cache=\"\"\n"
 423   },
 424   // Ignore wrong quotes no-cache value.
 425   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE,
 426     "HTTP/1.1 200 OK\n"
 427     "Foo: 2\n"
 428     "Cache-Control: private, no-cache=\'foo\'\n",
 429
 430     "HTTP/1.1 200 OK\n"
 431     "Foo: 2\n"
 432     "Cache-Control: private, no-cache=\'foo\'\n"
 433   },
 434   // Ignore unterminated quotes no-cache value.
 435   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE,
 436     "HTTP/1.1 200 OK\n"
 437     "Foo: 2\n"
 438     "Cache-Control: private, no-cache=\"foo\n",
 439
 440     "HTTP/1.1 200 OK\n"
 441     "Foo: 2\n"
 442     "Cache-Control: private, no-cache=\"foo\n"
 443   },
 444   // Accept sloppy LWS.
 445   { net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE,
 446     "HTTP/1.1 200 OK\n"
 447     "Foo: 2\n"
 448     "Cache-Control: private, no-cache=\" foo\t, bar\"\n",
 449
 450     "HTTP/1.1 200 OK\n"
 451     "Cache-Control: private, no-cache=\" foo\t, bar\"\n"
 452   },
 453   // Header name appears twice, separated by another header.
 454   { net::HttpResponseHeaders::PERSIST_ALL,
 455     "HTTP/1.1 200 OK\n"
 456     "Foo: 1\n"
 457     "Bar: 2\n"
 458     "Foo: 3\n",
 459
 460     "HTTP/1.1 200 OK\n"
 461     "Foo: 1, 3\n"
 462     "Bar: 2\n"
 463   },
 464   // Header name appears twice, separated by another header (type 2).
 465   { net::HttpResponseHeaders::PERSIST_ALL,
 466     "HTTP/1.1 200 OK\n"
 467     "Foo: 1, 3\n"
 468     "Bar: 2\n"
 469     "Foo: 4\n",
 470
 471     "HTTP/1.1 200 OK\n"
 472     "Foo: 1, 3, 4\n"
 473     "Bar: 2\n"
 474   },
 475   // Test filtering of cookie headers.
 476   { net::HttpResponseHeaders::PERSIST_SANS_COOKIES,
 477     "HTTP/1.1 200 OK\n"
 478     "Set-Cookie: foo=bar; httponly\n"
 479     "Set-Cookie: bar=foo\n"
 480     "Bar: 1\n"
 481     "Set-Cookie2: bar2=foo2\n",
 482
 483     "HTTP/1.1 200 OK\n"
 484     "Bar: 1\n"
 485   },
 486   // Test LWS at the end of a header.
 487   { net::HttpResponseHeaders::PERSIST_ALL,
 488     "HTTP/1.1 200 OK\n"
 489     "Content-Length: 450   \n"
 490     "Content-Encoding: gzip\n",
 491
 492     "HTTP/1.1 200 OK\n"
 493     "Content-Length: 450\n"
 494     "Content-Encoding: gzip\n"
 495   },
 496   // Test LWS at the end of a header.
 497   { net::HttpResponseHeaders::PERSIST_RAW,
 498     "HTTP/1.1 200 OK\n"
 499     "Content-Length: 450   \n"
 500     "Content-Encoding: gzip\n",
 501
 502     "HTTP/1.1 200 OK\n"
 503     "Content-Length: 450\n"
 504     "Content-Encoding: gzip\n"
 505   },
 506   // Test filtering of transport security state headers.
 507   { net::HttpResponseHeaders::PERSIST_SANS_SECURITY_STATE,
 508     "HTTP/1.1 200 OK\n"
 509     "Strict-Transport-Security: max-age=1576800\n"
 510     "Bar: 1\n"
 511     "Public-Key-Pins: max-age=100000; "
 512         "pin-sha1=\"ObT42aoSpAqWdY9WfRfL7i0HsVk=\";"
 513         "pin-sha1=\"7kW49EVwZG0hSNx41ZO/fUPN0ek=\"",
 514
 515     "HTTP/1.1 200 OK\n"
 516     "Bar: 1\n"
 517   },
 518 };
 519
 520 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
 521                         PersistenceTest,
 522                         testing::ValuesIn(persistence_tests));
 523
 524 TEST(HttpResponseHeadersTest, EnumerateHeader_Coalesced) {
 525   // Ensure that commas in quoted strings are not regarded as value separators.
 526   // Ensure that whitespace following a value is trimmed properly.
 527   std::string headers =
 528       "HTTP/1.1 200 OK\n"
 529       "Cache-control:private , no-cache=\"set-cookie,server\" \n"
 530       "cache-Control: no-store\n";
 531   HeadersToRaw(&headers);
 532   scoped_refptr<net::HttpResponseHeaders> parsed(
 533       new net::HttpResponseHeaders(headers));
 534
 535   void* iter = NULL;
 536   std::string value;
 537   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "cache-control", &value));
 538   EXPECT_EQ("private", value);
 539   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "cache-control", &value));
 540   EXPECT_EQ("no-cache=\"set-cookie,server\"", value);
 541   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "cache-control", &value));
 542   EXPECT_EQ("no-store", value);
 543   EXPECT_FALSE(parsed->EnumerateHeader(&iter, "cache-control", &value));
 544 }
 545
 546 TEST(HttpResponseHeadersTest, EnumerateHeader_Challenge) {
 547   // Even though WWW-Authenticate has commas, it should not be treated as
 548   // coalesced values.
 549   std::string headers =
 550       "HTTP/1.1 401 OK\n"
 551       "WWW-Authenticate:Digest realm=foobar, nonce=x, domain=y\n"
 552       "WWW-Authenticate:Basic realm=quatar\n";
 553   HeadersToRaw(&headers);
 554   scoped_refptr<net::HttpResponseHeaders> parsed(
 555       new net::HttpResponseHeaders(headers));
 556
 557   void* iter = NULL;
 558   std::string value;
 559   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "WWW-Authenticate", &value));
 560   EXPECT_EQ("Digest realm=foobar, nonce=x, domain=y", value);
 561   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "WWW-Authenticate", &value));
 562   EXPECT_EQ("Basic realm=quatar", value);
 563   EXPECT_FALSE(parsed->EnumerateHeader(&iter, "WWW-Authenticate", &value));
 564 }
 565
 566 TEST(HttpResponseHeadersTest, EnumerateHeader_DateValued) {
 567   // The comma in a date valued header should not be treated as a
 568   // field-value separator.
 569   std::string headers =
 570       "HTTP/1.1 200 OK\n"
 571       "Date: Tue, 07 Aug 2007 23:10:55 GMT\n"
 572       "Last-Modified: Wed, 01 Aug 2007 23:23:45 GMT\n";
 573   HeadersToRaw(&headers);
 574   scoped_refptr<net::HttpResponseHeaders> parsed(
 575       new net::HttpResponseHeaders(headers));
 576
 577   std::string value;
 578   EXPECT_TRUE(parsed->EnumerateHeader(NULL, "date", &value));
 579   EXPECT_EQ("Tue, 07 Aug 2007 23:10:55 GMT", value);
 580   EXPECT_TRUE(parsed->EnumerateHeader(NULL, "last-modified", &value));
 581   EXPECT_EQ("Wed, 01 Aug 2007 23:23:45 GMT", value);
 582 }
 583
 584 TEST(HttpResponseHeadersTest, DefaultDateToGMT) {
 585   // Verify we make the best interpretation when parsing dates that incorrectly
 586   // do not end in "GMT" as RFC2616 requires.
 587   std::string headers =
 588       "HTTP/1.1 200 OK\n"
 589       "Date: Tue, 07 Aug 2007 23:10:55\n"
 590       "Last-Modified: Tue, 07 Aug 2007 19:10:55 EDT\n"
 591       "Expires: Tue, 07 Aug 2007 23:10:55 UTC\n";
 592   HeadersToRaw(&headers);
 593   scoped_refptr<net::HttpResponseHeaders> parsed(
 594       new net::HttpResponseHeaders(headers));
 595   base::Time expected_value;
 596   ASSERT_TRUE(base::Time::FromString("Tue, 07 Aug 2007 23:10:55 GMT",
 597                                      &expected_value));
 598
 599   base::Time value;
 600   // When the timezone is missing, GMT is a good guess as its what RFC2616
 601   // requires.
 602   EXPECT_TRUE(parsed->GetDateValue(&value));
 603   EXPECT_EQ(expected_value, value);
 604   // If GMT is missing but an RFC822-conforming one is present, use that.
 605   EXPECT_TRUE(parsed->GetLastModifiedValue(&value));
 606   EXPECT_EQ(expected_value, value);
 607   // If an unknown timezone is present, treat like a missing timezone and
 608   // default to GMT.  The only example of a web server not specifying "GMT"
 609   // used "UTC" which is equivalent to GMT.
 610   if (parsed->GetExpiresValue(&value))
 611     EXPECT_EQ(expected_value, value);
 612 }
 613
 614 struct ContentTypeTestData {
 615   const std::string raw_headers;
 616   const std::string mime_type;
 617   const bool has_mimetype;
 618   const std::string charset;
 619   const bool has_charset;
 620   const std::string all_content_type;
 621 };
 622
 623 class ContentTypeTest
 624     : public HttpResponseHeadersTest,
 625       public ::testing::WithParamInterface<ContentTypeTestData> {
 626 };
 627
 628 TEST_P(ContentTypeTest, GetMimeType) {
 629   const ContentTypeTestData test = GetParam();
 630
 631   std::string headers(test.raw_headers);
 632   HeadersToRaw(&headers);
 633   scoped_refptr<net::HttpResponseHeaders> parsed(
 634       new net::HttpResponseHeaders(headers));
 635
 636   std::string value;
 637   EXPECT_EQ(test.has_mimetype, parsed->GetMimeType(&value));
 638   EXPECT_EQ(test.mime_type, value);
 639   value.clear();
 640   EXPECT_EQ(test.has_charset, parsed->GetCharset(&value));
 641   EXPECT_EQ(test.charset, value);
 642   EXPECT_TRUE(parsed->GetNormalizedHeader("content-type", &value));
 643   EXPECT_EQ(test.all_content_type, value);
 644 }
 645
 646 const ContentTypeTestData mimetype_tests[] = {
 647   { "HTTP/1.1 200 OK\n"
 648     "Content-type: text/html\n",
 649     "text/html", true,
 650     "", false,
 651     "text/html" },
 652   // Multiple content-type headers should give us the last one.
 653   { "HTTP/1.1 200 OK\n"
 654     "Content-type: text/html\n"
 655     "Content-type: text/html\n",
 656     "text/html", true,
 657     "", false,
 658     "text/html, text/html" },
 659   { "HTTP/1.1 200 OK\n"
 660     "Content-type: text/plain\n"
 661     "Content-type: text/html\n"
 662     "Content-type: text/plain\n"
 663     "Content-type: text/html\n",
 664     "text/html", true,
 665     "", false,
 666     "text/plain, text/html, text/plain, text/html" },
 667   // Test charset parsing.
 668   { "HTTP/1.1 200 OK\n"
 669     "Content-type: text/html\n"
 670     "Content-type: text/html; charset=ISO-8859-1\n",
 671     "text/html", true,
 672     "iso-8859-1", true,
 673     "text/html, text/html; charset=ISO-8859-1" },
 674   // Test charset in double quotes.
 675   { "HTTP/1.1 200 OK\n"
 676     "Content-type: text/html\n"
 677     "Content-type: text/html; charset=\"ISO-8859-1\"\n",
 678     "text/html", true,
 679     "iso-8859-1", true,
 680     "text/html, text/html; charset=\"ISO-8859-1\"" },
 681   // If there are multiple matching content-type headers, we carry
 682   // over the charset value.
 683   { "HTTP/1.1 200 OK\n"
 684     "Content-type: text/html;charset=utf-8\n"
 685     "Content-type: text/html\n",
 686     "text/html", true,
 687     "utf-8", true,
 688     "text/html;charset=utf-8, text/html" },
 689   // Test single quotes.
 690   { "HTTP/1.1 200 OK\n"
 691     "Content-type: text/html;charset='utf-8'\n"
 692     "Content-type: text/html\n",
 693     "text/html", true,
 694     "utf-8", true,
 695     "text/html;charset='utf-8', text/html" },
 696   // Last charset wins if matching content-type.
 697   { "HTTP/1.1 200 OK\n"
 698     "Content-type: text/html;charset=utf-8\n"
 699     "Content-type: text/html;charset=iso-8859-1\n",
 700     "text/html", true,
 701     "iso-8859-1", true,
 702     "text/html;charset=utf-8, text/html;charset=iso-8859-1" },
 703   // Charset is ignored if the content types change.
 704   { "HTTP/1.1 200 OK\n"
 705     "Content-type: text/plain;charset=utf-8\n"
 706     "Content-type: text/html\n",
 707     "text/html", true,
 708     "", false,
 709     "text/plain;charset=utf-8, text/html" },
 710   // Empty content-type.
 711   { "HTTP/1.1 200 OK\n"
 712     "Content-type: \n",
 713     "", false,
 714     "", false,
 715     "" },
 716   // Emtpy charset.
 717   { "HTTP/1.1 200 OK\n"
 718     "Content-type: text/html;charset=\n",
 719     "text/html", true,
 720     "", false,
 721     "text/html;charset=" },
 722   // Multiple charsets, last one wins.
 723   { "HTTP/1.1 200 OK\n"
 724     "Content-type: text/html;charset=utf-8; charset=iso-8859-1\n",
 725     "text/html", true,
 726     "iso-8859-1", true,
 727     "text/html;charset=utf-8; charset=iso-8859-1" },
 728   // Multiple params.
 729   { "HTTP/1.1 200 OK\n"
 730     "Content-type: text/html; foo=utf-8; charset=iso-8859-1\n",
 731     "text/html", true,
 732     "iso-8859-1", true,
 733     "text/html; foo=utf-8; charset=iso-8859-1" },
 734   { "HTTP/1.1 200 OK\n"
 735     "Content-type: text/html ; charset=utf-8 ; bar=iso-8859-1\n",
 736     "text/html", true,
 737     "utf-8", true,
 738     "text/html ; charset=utf-8 ; bar=iso-8859-1" },
 739   // Comma embeded in quotes.
 740   { "HTTP/1.1 200 OK\n"
 741     "Content-type: text/html ; charset='utf-8,text/plain' ;\n",
 742     "text/html", true,
 743     "utf-8,text/plain", true,
 744     "text/html ; charset='utf-8,text/plain' ;" },
 745   // Charset with leading spaces.
 746   { "HTTP/1.1 200 OK\n"
 747     "Content-type: text/html ; charset= 'utf-8' ;\n",
 748     "text/html", true,
 749     "utf-8", true,
 750     "text/html ; charset= 'utf-8' ;" },
 751   // Media type comments in mime-type.
 752   { "HTTP/1.1 200 OK\n"
 753     "Content-type: text/html (html)\n",
 754     "text/html", true,
 755     "", false,
 756    "text/html (html)" },
 757   // Incomplete charset= param.
 758   { "HTTP/1.1 200 OK\n"
 759     "Content-type: text/html; char=\n",
 760     "text/html", true,
 761     "", false,
 762     "text/html; char=" },
 763   // Invalid media type: no slash.
 764   { "HTTP/1.1 200 OK\n"
 765     "Content-type: texthtml\n",
 766     "", false,
 767     "", false,
 768     "texthtml" },
 769   // Invalid media type: "*/*".
 770   { "HTTP/1.1 200 OK\n"
 771     "Content-type: */*\n",
 772     "", false,
 773     "", false,
 774     "*/*" },
 775 };
 776
 777 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
 778                         ContentTypeTest,
 779                         testing::ValuesIn(mimetype_tests));
 780
 781 using net::ValidationType;
 782 using net::VALIDATION_NONE;
 783 using net::VALIDATION_SYNCHRONOUS;
 784 using net::VALIDATION_ASYNCHRONOUS;
 785
 786 struct RequiresValidationTestData {
 787   const char* headers;
 788   ValidationType validation_type;
 789 };
 790
 791 class RequiresValidationTest
 792     : public HttpResponseHeadersTest,
 793       public ::testing::WithParamInterface<RequiresValidationTestData> {
 794 };
 795
 796 TEST_P(RequiresValidationTest, RequiresValidation) {
 797   const RequiresValidationTestData test = GetParam();
 798
 799   base::Time request_time, response_time, current_time;
 800   base::Time::FromString("Wed, 28 Nov 2007 00:40:09 GMT", &request_time);
 801   base::Time::FromString("Wed, 28 Nov 2007 00:40:12 GMT", &response_time);
 802   base::Time::FromString("Wed, 28 Nov 2007 00:45:20 GMT", &current_time);
 803
 804   std::string headers(test.headers);
 805   HeadersToRaw(&headers);
 806   scoped_refptr<net::HttpResponseHeaders> parsed(
 807       new net::HttpResponseHeaders(headers));
 808
 809   ValidationType validation_type =
 810       parsed->RequiresValidation(request_time, response_time, current_time);
 811   EXPECT_EQ(test.validation_type, validation_type);
 812 }
 813
 814 const struct RequiresValidationTestData requires_validation_tests[] = {
 815   // No expiry info: expires immediately.
 816   { "HTTP/1.1 200 OK\n"
 817     "\n",
 818     VALIDATION_SYNCHRONOUS
 819   },
 820   // No expiry info: expires immediately.
 821   { "HTTP/1.1 200 OK\n"
 822     "\n",
 823     VALIDATION_SYNCHRONOUS
 824   },
 825   // Valid for a little while.
 826   { "HTTP/1.1 200 OK\n"
 827     "cache-control: max-age=10000\n"
 828     "\n",
 829     VALIDATION_NONE
 830   },
 831   // Expires in the future.
 832   { "HTTP/1.1 200 OK\n"
 833     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 834     "expires: Wed, 28 Nov 2007 01:00:00 GMT\n"
 835     "\n",
 836     VALIDATION_NONE
 837   },
 838   // Already expired.
 839   { "HTTP/1.1 200 OK\n"
 840     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 841     "expires: Wed, 28 Nov 2007 00:00:00 GMT\n"
 842     "\n",
 843     VALIDATION_SYNCHRONOUS
 844   },
 845   // Max-age trumps expires.
 846   { "HTTP/1.1 200 OK\n"
 847     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 848     "expires: Wed, 28 Nov 2007 00:00:00 GMT\n"
 849     "cache-control: max-age=10000\n"
 850     "\n",
 851     VALIDATION_NONE
 852   },
 853   // Last-modified heuristic: modified a while ago.
 854   { "HTTP/1.1 200 OK\n"
 855     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 856     "last-modified: Wed, 27 Nov 2007 08:00:00 GMT\n"
 857     "\n",
 858     VALIDATION_NONE
 859   },
 860   { "HTTP/1.1 203 Non-Authoritative Information\n"
 861     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 862     "last-modified: Wed, 27 Nov 2007 08:00:00 GMT\n"
 863     "\n",
 864     VALIDATION_NONE
 865   },
 866   { "HTTP/1.1 206 Partial Content\n"
 867     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 868     "last-modified: Wed, 27 Nov 2007 08:00:00 GMT\n"
 869     "\n",
 870     VALIDATION_NONE
 871   },
 872   // Last-modified heuristic: modified recently.
 873   { "HTTP/1.1 200 OK\n"
 874     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 875     "last-modified: Wed, 28 Nov 2007 00:40:10 GMT\n"
 876     "\n",
 877     VALIDATION_SYNCHRONOUS
 878   },
 879   { "HTTP/1.1 203 Non-Authoritative Information\n"
 880     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 881     "last-modified: Wed, 28 Nov 2007 00:40:10 GMT\n"
 882     "\n",
 883     VALIDATION_SYNCHRONOUS
 884   },
 885   { "HTTP/1.1 206 Partial Content\n"
 886   "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 887     "last-modified: Wed, 28 Nov 2007 00:40:10 GMT\n"
 888     "\n",
 889     VALIDATION_SYNCHRONOUS
 890   },
 891   // Cached permanent redirect.
 892   { "HTTP/1.1 301 Moved Permanently\n"
 893     "\n",
 894     VALIDATION_NONE
 895   },
 896   // Another cached permanent redirect.
 897   { "HTTP/1.1 308 Permanent Redirect\n"
 898     "\n",
 899     VALIDATION_NONE
 900   },
 901   // Cached redirect: not reusable even though by default it would be.
 902   { "HTTP/1.1 300 Multiple Choices\n"
 903     "Cache-Control: no-cache\n"
 904     "\n",
 905     VALIDATION_SYNCHRONOUS
 906   },
 907   // Cached forever by default.
 908   { "HTTP/1.1 410 Gone\n"
 909     "\n",
 910     VALIDATION_NONE
 911   },
 912   // Cached temporary redirect: not reusable.
 913   { "HTTP/1.1 302 Found\n"
 914     "\n",
 915     VALIDATION_SYNCHRONOUS
 916   },
 917   // Cached temporary redirect: reusable.
 918   { "HTTP/1.1 302 Found\n"
 919     "cache-control: max-age=10000\n"
 920     "\n",
 921     VALIDATION_NONE
 922   },
 923   // Cache-control: max-age=N overrides expires: date in the past.
 924   { "HTTP/1.1 200 OK\n"
 925     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 926     "expires: Wed, 28 Nov 2007 00:20:11 GMT\n"
 927     "cache-control: max-age=10000\n"
 928     "\n",
 929     VALIDATION_NONE
 930   },
 931   // Cache-control: no-store overrides expires: in the future.
 932   { "HTTP/1.1 200 OK\n"
 933     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 934     "expires: Wed, 29 Nov 2007 00:40:11 GMT\n"
 935     "cache-control: no-store,private,no-cache=\"foo\"\n"
 936     "\n",
 937     VALIDATION_SYNCHRONOUS
 938   },
 939   // Pragma: no-cache overrides last-modified heuristic.
 940   { "HTTP/1.1 200 OK\n"
 941     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 942     "last-modified: Wed, 27 Nov 2007 08:00:00 GMT\n"
 943     "pragma: no-cache\n"
 944     "\n",
 945     VALIDATION_SYNCHRONOUS
 946   },
 947   // max-age has expired, needs synchronous revalidation
 948   { "HTTP/1.1 200 OK\n"
 949     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 950     "cache-control: max-age=300\n"
 951     "\n",
 952     VALIDATION_SYNCHRONOUS
 953   },
 954   // max-age has expired, stale-while-revalidate has not, eligible for
 955   // asynchronous revalidation
 956   { "HTTP/1.1 200 OK\n"
 957     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 958     "cache-control: max-age=300, stale-while-revalidate=3600\n"
 959     "\n",
 960     VALIDATION_ASYNCHRONOUS
 961   },
 962   // max-age and stale-while-revalidate have expired, needs synchronous
 963   // revalidation
 964   { "HTTP/1.1 200 OK\n"
 965     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 966     "cache-control: max-age=300, stale-while-revalidate=5\n"
 967     "\n",
 968     VALIDATION_SYNCHRONOUS
 969   },
 970   // max-age is 0, stale-while-revalidate is large enough to permit
 971   // asynchronous revalidation
 972   { "HTTP/1.1 200 OK\n"
 973     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 974     "cache-control: max-age=0, stale-while-revalidate=360\n"
 975     "\n",
 976     VALIDATION_ASYNCHRONOUS
 977   },
 978   // stale-while-revalidate must not override no-cache or similar directives.
 979   { "HTTP/1.1 200 OK\n"
 980     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 981     "cache-control: no-cache, stale-while-revalidate=360\n"
 982     "\n",
 983     VALIDATION_SYNCHRONOUS
 984   },
 985   // max-age has not expired, so no revalidation is needed.
 986   { "HTTP/1.1 200 OK\n"
 987     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 988     "cache-control: max-age=3600, stale-while-revalidate=3600\n"
 989     "\n",
 990     VALIDATION_NONE
 991   },
 992   // must-revalidate overrides stale-while-revalidate, so synchronous validation
 993   // is needed.
 994   { "HTTP/1.1 200 OK\n"
 995     "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
 996     "cache-control: must-revalidate, max-age=300, stale-while-revalidate=3600\n"
 997     "\n",
 998     VALIDATION_SYNCHRONOUS
 999   },
1000
1001   // TODO(darin): Add many many more tests here.
1002 };
1003
1004 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1005                         RequiresValidationTest,
1006                         testing::ValuesIn(requires_validation_tests));
1007
1008 struct UpdateTestData {
1009   const char* orig_headers;
1010   const char* new_headers;
1011   const char* expected_headers;
1012 };
1013
1014 class UpdateTest
1015     : public HttpResponseHeadersTest,
1016       public ::testing::WithParamInterface<UpdateTestData> {
1017 };
1018
1019 TEST_P(UpdateTest, Update) {
1020   const UpdateTestData test = GetParam();
1021
1022   std::string orig_headers(test.orig_headers);
1023   HeadersToRaw(&orig_headers);
1024   scoped_refptr<net::HttpResponseHeaders> parsed(
1025       new net::HttpResponseHeaders(orig_headers));
1026
1027   std::string new_headers(test.new_headers);
1028   HeadersToRaw(&new_headers);
1029   scoped_refptr<net::HttpResponseHeaders> new_parsed(
1030       new net::HttpResponseHeaders(new_headers));
1031
1032   parsed->Update(*new_parsed.get());
1033
1034   std::string resulting_headers;
1035   parsed->GetNormalizedHeaders(&resulting_headers);
1036   EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
1037 }
1038
1039 const UpdateTestData update_tests[] = {
1040   { "HTTP/1.1 200 OK\n",
1041
1042     "HTTP/1/1 304 Not Modified\n"
1043     "connection: keep-alive\n"
1044     "Cache-control: max-age=10000\n",
1045
1046     "HTTP/1.1 200 OK\n"
1047     "Cache-control: max-age=10000\n"
1048   },
1049   { "HTTP/1.1 200 OK\n"
1050     "Foo: 1\n"
1051     "Cache-control: private\n",
1052
1053     "HTTP/1/1 304 Not Modified\n"
1054     "connection: keep-alive\n"
1055     "Cache-control: max-age=10000\n",
1056
1057     "HTTP/1.1 200 OK\n"
1058     "Cache-control: max-age=10000\n"
1059     "Foo: 1\n"
1060   },
1061   { "HTTP/1.1 200 OK\n"
1062     "Foo: 1\n"
1063     "Cache-control: private\n",
1064
1065     "HTTP/1/1 304 Not Modified\n"
1066     "connection: keep-alive\n"
1067     "Cache-CONTROL: max-age=10000\n",
1068
1069     "HTTP/1.1 200 OK\n"
1070     "Cache-CONTROL: max-age=10000\n"
1071     "Foo: 1\n"
1072   },
1073   { "HTTP/1.1 200 OK\n"
1074     "Content-Length: 450\n",
1075
1076     "HTTP/1/1 304 Not Modified\n"
1077     "connection: keep-alive\n"
1078     "Cache-control:      max-age=10001   \n",
1079
1080     "HTTP/1.1 200 OK\n"
1081     "Cache-control: max-age=10001\n"
1082     "Content-Length: 450\n"
1083   },
1084   { "HTTP/1.1 200 OK\n"
1085     "X-Frame-Options: DENY\n",
1086
1087     "HTTP/1/1 304 Not Modified\n"
1088     "X-Frame-Options: ALLOW\n",
1089
1090     "HTTP/1.1 200 OK\n"
1091     "X-Frame-Options: DENY\n",
1092   },
1093   { "HTTP/1.1 200 OK\n"
1094     "X-WebKit-CSP: default-src 'none'\n",
1095
1096     "HTTP/1/1 304 Not Modified\n"
1097     "X-WebKit-CSP: default-src *\n",
1098
1099     "HTTP/1.1 200 OK\n"
1100     "X-WebKit-CSP: default-src 'none'\n",
1101   },
1102   { "HTTP/1.1 200 OK\n"
1103     "X-XSS-Protection: 1\n",
1104
1105     "HTTP/1/1 304 Not Modified\n"
1106     "X-XSS-Protection: 0\n",
1107
1108     "HTTP/1.1 200 OK\n"
1109     "X-XSS-Protection: 1\n",
1110   },
1111   { "HTTP/1.1 200 OK\n",
1112
1113     "HTTP/1/1 304 Not Modified\n"
1114     "X-Content-Type-Options: nosniff\n",
1115
1116     "HTTP/1.1 200 OK\n"
1117   },
1118 };
1119
1120 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1121                         UpdateTest,
1122                         testing::ValuesIn(update_tests));
1123
1124 struct EnumerateHeaderTestData {
1125   const char* headers;
1126   const char* expected_lines;
1127 };
1128
1129 class EnumerateHeaderLinesTest
1130     : public HttpResponseHeadersTest,
1131       public ::testing::WithParamInterface<EnumerateHeaderTestData> {
1132 };
1133
1134 TEST_P(EnumerateHeaderLinesTest, EnumerateHeaderLines) {
1135   const EnumerateHeaderTestData test = GetParam();
1136
1137   std::string headers(test.headers);
1138   HeadersToRaw(&headers);
1139   scoped_refptr<net::HttpResponseHeaders> parsed(
1140       new net::HttpResponseHeaders(headers));
1141
1142   std::string name, value, lines;
1143
1144   void* iter = NULL;
1145   while (parsed->EnumerateHeaderLines(&iter, &name, &value)) {
1146     lines.append(name);
1147     lines.append(": ");
1148     lines.append(value);
1149     lines.append("\n");
1150   }
1151
1152   EXPECT_EQ(std::string(test.expected_lines), lines);
1153 }
1154
1155 const EnumerateHeaderTestData enumerate_header_tests[] = {
1156   { "HTTP/1.1 200 OK\n",
1157
1158     ""
1159   },
1160   { "HTTP/1.1 200 OK\n"
1161     "Foo: 1\n",
1162
1163     "Foo: 1\n"
1164   },
1165   { "HTTP/1.1 200 OK\n"
1166     "Foo: 1\n"
1167     "Bar: 2\n"
1168     "Foo: 3\n",
1169
1170     "Foo: 1\nBar: 2\nFoo: 3\n"
1171   },
1172   { "HTTP/1.1 200 OK\n"
1173     "Foo: 1, 2, 3\n",
1174
1175     "Foo: 1, 2, 3\n"
1176   },
1177 };
1178
1179 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1180                         EnumerateHeaderLinesTest,
1181                         testing::ValuesIn(enumerate_header_tests));
1182
1183 struct IsRedirectTestData {
1184   const char* headers;
1185   const char* location;
1186   bool is_redirect;
1187 };
1188
1189 class IsRedirectTest
1190     : public HttpResponseHeadersTest,
1191       public ::testing::WithParamInterface<IsRedirectTestData> {
1192 };
1193
1194 TEST_P(IsRedirectTest, IsRedirect) {
1195   const IsRedirectTestData test = GetParam();
1196
1197   std::string headers(test.headers);
1198   HeadersToRaw(&headers);
1199   scoped_refptr<net::HttpResponseHeaders> parsed(
1200       new net::HttpResponseHeaders(headers));
1201
1202   std::string location;
1203   EXPECT_EQ(parsed->IsRedirect(&location), test.is_redirect);
1204   EXPECT_EQ(location, test.location);
1205 }
1206
1207 const IsRedirectTestData is_redirect_tests[] = {
1208   { "HTTP/1.1 200 OK\n",
1209     "",
1210     false
1211   },
1212   { "HTTP/1.1 301 Moved\n"
1213     "Location: http://foopy/\n",
1214     "http://foopy/",
1215     true
1216   },
1217   { "HTTP/1.1 301 Moved\n"
1218     "Location: \t \n",
1219     "",
1220     false
1221   },
1222   // We use the first location header as the target of the redirect.
1223   { "HTTP/1.1 301 Moved\n"
1224     "Location: http://foo/\n"
1225     "Location: http://bar/\n",
1226     "http://foo/",
1227     true
1228   },
1229   // We use the first _valid_ location header as the target of the redirect.
1230   { "HTTP/1.1 301 Moved\n"
1231     "Location: \n"
1232     "Location: http://bar/\n",
1233     "http://bar/",
1234     true
1235   },
1236   // Bug 1050541 (location header with an unescaped comma).
1237   { "HTTP/1.1 301 Moved\n"
1238     "Location: http://foo/bar,baz.html\n",
1239     "http://foo/bar,baz.html",
1240     true
1241   },
1242   // Bug 1224617 (location header with non-ASCII bytes).
1243   { "HTTP/1.1 301 Moved\n"
1244     "Location: http://foo/bar?key=\xE4\xF6\xFC\n",
1245     "http://foo/bar?key=%E4%F6%FC",
1246     true
1247   },
1248   // Shift_JIS, Big5, and GBK contain multibyte characters with the trailing
1249   // byte falling in the ASCII range.
1250   { "HTTP/1.1 301 Moved\n"
1251     "Location: http://foo/bar?key=\x81\x5E\xD8\xBF\n",
1252     "http://foo/bar?key=%81^%D8%BF",
1253     true
1254   },
1255   { "HTTP/1.1 301 Moved\n"
1256     "Location: http://foo/bar?key=\x82\x40\xBD\xC4\n",
1257     "http://foo/bar?key=%82@%BD%C4",
1258     true
1259   },
1260   { "HTTP/1.1 301 Moved\n"
1261     "Location: http://foo/bar?key=\x83\x5C\x82\x5D\xCB\xD7\n",
1262     "http://foo/bar?key=%83\\%82]%CB%D7",
1263     true
1264   },
1265 };
1266
1267 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1268                         IsRedirectTest,
1269                         testing::ValuesIn(is_redirect_tests));
1270
1271 struct ContentLengthTestData {
1272   const char* headers;
1273   int64 expected_len;
1274 };
1275
1276 class GetContentLengthTest
1277     : public HttpResponseHeadersTest,
1278       public ::testing::WithParamInterface<ContentLengthTestData> {
1279 };
1280
1281 TEST_P(GetContentLengthTest, GetContentLength) {
1282   const ContentLengthTestData test = GetParam();
1283
1284   std::string headers(test.headers);
1285   HeadersToRaw(&headers);
1286   scoped_refptr<net::HttpResponseHeaders> parsed(
1287       new net::HttpResponseHeaders(headers));
1288
1289   EXPECT_EQ(test.expected_len, parsed->GetContentLength());
1290 }
1291
1292 const ContentLengthTestData content_length_tests[] = {
1293   { "HTTP/1.1 200 OK\n",
1294     -1
1295   },
1296   { "HTTP/1.1 200 OK\n"
1297     "Content-Length: 10\n",
1298     10
1299   },
1300   { "HTTP/1.1 200 OK\n"
1301     "Content-Length: \n",
1302     -1
1303   },
1304   { "HTTP/1.1 200 OK\n"
1305     "Content-Length: abc\n",
1306     -1
1307   },
1308   { "HTTP/1.1 200 OK\n"
1309     "Content-Length: -10\n",
1310     -1
1311   },
1312   { "HTTP/1.1 200 OK\n"
1313     "Content-Length:  +10\n",
1314     -1
1315   },
1316   { "HTTP/1.1 200 OK\n"
1317     "Content-Length: 23xb5\n",
1318     -1
1319   },
1320   { "HTTP/1.1 200 OK\n"
1321     "Content-Length: 0xA\n",
1322     -1
1323   },
1324   { "HTTP/1.1 200 OK\n"
1325     "Content-Length: 010\n",
1326     10
1327   },
1328   // Content-Length too big, will overflow an int64.
1329   { "HTTP/1.1 200 OK\n"
1330     "Content-Length: 40000000000000000000\n",
1331     -1
1332   },
1333   { "HTTP/1.1 200 OK\n"
1334     "Content-Length:       10\n",
1335     10
1336   },
1337   { "HTTP/1.1 200 OK\n"
1338     "Content-Length: 10  \n",
1339     10
1340   },
1341   { "HTTP/1.1 200 OK\n"
1342     "Content-Length: \t10\n",
1343     10
1344   },
1345   { "HTTP/1.1 200 OK\n"
1346     "Content-Length: \v10\n",
1347     -1
1348   },
1349   { "HTTP/1.1 200 OK\n"
1350     "Content-Length: \f10\n",
1351     -1
1352   },
1353   { "HTTP/1.1 200 OK\n"
1354     "cOnTeNt-LENgth: 33\n",
1355     33
1356   },
1357   { "HTTP/1.1 200 OK\n"
1358     "Content-Length: 34\r\n",
1359     -1
1360   },
1361 };
1362
1363 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1364                         GetContentLengthTest,
1365                         testing::ValuesIn(content_length_tests));
1366
1367 struct ContentRangeTestData {
1368   const char* headers;
1369   bool expected_return_value;
1370   int64 expected_first_byte_position;
1371   int64 expected_last_byte_position;
1372   int64 expected_instance_size;
1373 };
1374
1375 class ContentRangeTest
1376     : public HttpResponseHeadersTest,
1377       public ::testing::WithParamInterface<ContentRangeTestData> {
1378 };
1379
1380 TEST_P(ContentRangeTest, GetContentRange) {
1381   const ContentRangeTestData test = GetParam();
1382
1383   std::string headers(test.headers);
1384   HeadersToRaw(&headers);
1385   scoped_refptr<net::HttpResponseHeaders> parsed(
1386       new net::HttpResponseHeaders(headers));
1387
1388   int64 first_byte_position;
1389   int64 last_byte_position;
1390   int64 instance_size;
1391   bool return_value = parsed->GetContentRange(&first_byte_position,
1392                                               &last_byte_position,
1393                                               &instance_size);
1394   EXPECT_EQ(test.expected_return_value, return_value);
1395   EXPECT_EQ(test.expected_first_byte_position, first_byte_position);
1396   EXPECT_EQ(test.expected_last_byte_position, last_byte_position);
1397   EXPECT_EQ(test.expected_instance_size, instance_size);
1398 }
1399
1400 const ContentRangeTestData content_range_tests[] = {
1401   { "HTTP/1.1 206 Partial Content",
1402     false,
1403     -1,
1404     -1,
1405     -1
1406   },
1407   { "HTTP/1.1 206 Partial Content\n"
1408     "Content-Range:",
1409     false,
1410     -1,
1411     -1,
1412     -1
1413   },
1414   { "HTTP/1.1 206 Partial Content\n"
1415     "Content-Range: megabytes 0-10/50",
1416     false,
1417     -1,
1418     -1,
1419     -1
1420   },
1421   { "HTTP/1.1 206 Partial Content\n"
1422     "Content-Range: 0-10/50",
1423     false,
1424     -1,
1425     -1,
1426     -1
1427   },
1428   { "HTTP/1.1 206 Partial Content\n"
1429     "Content-Range: Bytes 0-50/51",
1430     true,
1431     0,
1432     50,
1433     51
1434   },
1435   { "HTTP/1.1 206 Partial Content\n"
1436     "Content-Range: bytes 0-50/51",
1437     true,
1438     0,
1439     50,
1440     51
1441   },
1442   { "HTTP/1.1 206 Partial Content\n"
1443     "Content-Range: bytes\t0-50/51",
1444     false,
1445     -1,
1446     -1,
1447     -1
1448   },
1449   { "HTTP/1.1 206 Partial Content\n"
1450     "Content-Range:     bytes 0-50/51",
1451     true,
1452     0,
1453     50,
1454     51
1455   },
1456   { "HTTP/1.1 206 Partial Content\n"
1457     "Content-Range:     bytes    0    -   50  \t / \t51",
1458     true,
1459     0,
1460     50,
1461     51
1462   },
1463   { "HTTP/1.1 206 Partial Content\n"
1464     "Content-Range: bytes 0\t-\t50\t/\t51\t",
1465     true,
1466     0,
1467     50,
1468     51
1469   },
1470   { "HTTP/1.1 206 Partial Content\n"
1471     "Content-Range:   \tbytes\t\t\t 0\t-\t50\t/\t51\t",
1472     true,
1473     0,
1474     50,
1475     51
1476   },
1477   { "HTTP/1.1 206 Partial Content\n"
1478     "Content-Range: \t   bytes \t  0    -   50   /   5   1",
1479     false,
1480     0,
1481     50,
1482     -1
1483   },
1484   { "HTTP/1.1 206 Partial Content\n"
1485     "Content-Range: \t   bytes \t  0    -   5 0   /   51",
1486     false,
1487     -1,
1488     -1,
1489     -1
1490   },
1491   { "HTTP/1.1 206 Partial Content\n"
1492     "Content-Range: bytes 50-0/51",
1493     false,
1494     50,
1495     0,
1496     -1
1497   },
1498   { "HTTP/1.1 416 Requested range not satisfiable\n"
1499     "Content-Range: bytes * /*",
1500     false,
1501     -1,
1502     -1,
1503     -1
1504   },
1505   { "HTTP/1.1 416 Requested range not satisfiable\n"
1506     "Content-Range: bytes *   /    *   ",
1507     false,
1508     -1,
1509     -1,
1510     -1
1511   },
1512   { "HTTP/1.1 206 Partial Content\n"
1513     "Content-Range: bytes 0-50/*",
1514     false,
1515     0,
1516     50,
1517     -1
1518   },
1519   { "HTTP/1.1 206 Partial Content\n"
1520     "Content-Range: bytes 0-50  /    * ",
1521     false,
1522     0,
1523     50,
1524     -1
1525   },
1526   { "HTTP/1.1 206 Partial Content\n"
1527     "Content-Range: bytes 0-10000000000/10000000001",
1528     true,
1529     0,
1530     10000000000ll,
1531     10000000001ll
1532   },
1533   { "HTTP/1.1 206 Partial Content\n"
1534     "Content-Range: bytes 0-10000000000/10000000000",
1535     false,
1536     0,
1537     10000000000ll,
1538     10000000000ll
1539   },
1540   // 64 bit wraparound.
1541   { "HTTP/1.1 206 Partial Content\n"
1542     "Content-Range: bytes 0 - 9223372036854775807 / 100",
1543     false,
1544     0,
1545     kint64max,
1546     100
1547   },
1548   // 64 bit wraparound.
1549   { "HTTP/1.1 206 Partial Content\n"
1550     "Content-Range: bytes 0 - 100 / -9223372036854775808",
1551     false,
1552     0,
1553     100,
1554     kint64min
1555   },
1556   { "HTTP/1.1 206 Partial Content\n"
1557     "Content-Range: bytes */50",
1558     false,
1559     -1,
1560     -1,
1561     50
1562   },
1563   { "HTTP/1.1 206 Partial Content\n"
1564     "Content-Range: bytes 0-50/10",
1565     false,
1566     0,
1567     50,
1568     10
1569   },
1570   { "HTTP/1.1 206 Partial Content\n"
1571     "Content-Range: bytes 40-50/45",
1572     false,
1573     40,
1574     50,
1575     45
1576   },
1577   { "HTTP/1.1 206 Partial Content\n"
1578     "Content-Range: bytes 0-50/-10",
1579     false,
1580     0,
1581     50,
1582     -10
1583   },
1584   { "HTTP/1.1 206 Partial Content\n"
1585     "Content-Range: bytes 0-0/1",
1586     true,
1587     0,
1588     0,
1589     1
1590   },
1591   { "HTTP/1.1 206 Partial Content\n"
1592     "Content-Range: bytes 0-40000000000000000000/40000000000000000001",
1593     false,
1594     -1,
1595     -1,
1596     -1
1597   },
1598   { "HTTP/1.1 206 Partial Content\n"
1599     "Content-Range: bytes 1-/100",
1600     false,
1601     -1,
1602     -1,
1603     -1
1604   },
1605   { "HTTP/1.1 206 Partial Content\n"
1606     "Content-Range: bytes -/100",
1607     false,
1608     -1,
1609     -1,
1610     -1
1611   },
1612   { "HTTP/1.1 206 Partial Content\n"
1613     "Content-Range: bytes -1/100",
1614     false,
1615     -1,
1616     -1,
1617     -1
1618   },
1619   { "HTTP/1.1 206 Partial Content\n"
1620     "Content-Range: bytes 0-1233/*",
1621     false,
1622     0,
1623     1233,
1624     -1
1625   },
1626   { "HTTP/1.1 206 Partial Content\n"
1627     "Content-Range: bytes -123 - -1/100",
1628     false,
1629     -1,
1630     -1,
1631     -1
1632   },
1633 };
1634
1635 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1636                         ContentRangeTest,
1637                         testing::ValuesIn(content_range_tests));
1638
1639 struct KeepAliveTestData {
1640   const char* headers;
1641   bool expected_keep_alive;
1642 };
1643
1644 // Enable GTest to print KeepAliveTestData in an intelligible way if the test
1645 // fails.
1646 void PrintTo(const KeepAliveTestData& keep_alive_test_data,
1647              std::ostream* os) {
1648   *os << "{\"" << keep_alive_test_data.headers << "\", " << std::boolalpha
1649       << keep_alive_test_data.expected_keep_alive << "}";
1650 }
1651
1652 class IsKeepAliveTest
1653     : public HttpResponseHeadersTest,
1654       public ::testing::WithParamInterface<KeepAliveTestData> {
1655 };
1656
1657 TEST_P(IsKeepAliveTest, IsKeepAlive) {
1658   const KeepAliveTestData test = GetParam();
1659
1660   std::string headers(test.headers);
1661   HeadersToRaw(&headers);
1662   scoped_refptr<net::HttpResponseHeaders> parsed(
1663       new net::HttpResponseHeaders(headers));
1664
1665   EXPECT_EQ(test.expected_keep_alive, parsed->IsKeepAlive());
1666 }
1667
1668 const KeepAliveTestData keepalive_tests[] = {
1669   // The status line fabricated by HttpNetworkTransaction for a 0.9 response.
1670   // Treated as 0.9.
1671   { "HTTP/0.9 200 OK",
1672     false
1673   },
1674   // This could come from a broken server.  Treated as 1.0 because it has a
1675   // header.
1676   { "HTTP/0.9 200 OK\n"
1677     "connection: keep-alive\n",
1678     true
1679   },
1680   { "HTTP/1.1 200 OK\n",
1681     true
1682   },
1683   { "HTTP/1.0 200 OK\n",
1684     false
1685   },
1686   { "HTTP/1.0 200 OK\n"
1687     "connection: close\n",
1688     false
1689   },
1690   { "HTTP/1.0 200 OK\n"
1691     "connection: keep-alive\n",
1692     true
1693   },
1694   { "HTTP/1.0 200 OK\n"
1695     "connection: kEeP-AliVe\n",
1696     true
1697   },
1698   { "HTTP/1.0 200 OK\n"
1699     "connection: keep-aliveX\n",
1700     false
1701   },
1702   { "HTTP/1.1 200 OK\n"
1703     "connection: close\n",
1704     false
1705   },
1706   { "HTTP/1.1 200 OK\n"
1707     "connection: keep-alive\n",
1708     true
1709   },
1710   { "HTTP/1.0 200 OK\n"
1711     "proxy-connection: close\n",
1712     false
1713   },
1714   { "HTTP/1.0 200 OK\n"
1715     "proxy-connection: keep-alive\n",
1716     true
1717   },
1718   { "HTTP/1.1 200 OK\n"
1719     "proxy-connection: close\n",
1720     false
1721   },
1722   { "HTTP/1.1 200 OK\n"
1723     "proxy-connection: keep-alive\n",
1724     true
1725   },
1726   { "HTTP/1.1 200 OK\n"
1727     "Connection: Upgrade, close\n",
1728     false
1729   },
1730   { "HTTP/1.1 200 OK\n"
1731     "Connection: Upgrade, keep-alive\n",
1732     true
1733   },
1734   { "HTTP/1.1 200 OK\n"
1735     "Connection: Upgrade\n"
1736     "Connection: close\n",
1737     false
1738   },
1739   { "HTTP/1.1 200 OK\n"
1740     "Connection: Upgrade\n"
1741     "Connection: keep-alive\n",
1742     true
1743   },
1744   { "HTTP/1.1 200 OK\n"
1745     "Connection: close, Upgrade\n",
1746     false
1747   },
1748   { "HTTP/1.1 200 OK\n"
1749     "Connection: keep-alive, Upgrade\n",
1750     true
1751   },
1752   { "HTTP/1.1 200 OK\n"
1753     "Connection: Upgrade\n"
1754     "Proxy-Connection: close\n",
1755     false
1756   },
1757   { "HTTP/1.1 200 OK\n"
1758     "Connection: Upgrade\n"
1759     "Proxy-Connection: keep-alive\n",
1760     true
1761   },
1762   // In situations where the response headers conflict with themselves, use the
1763   // first one for backwards-compatibility.
1764   { "HTTP/1.1 200 OK\n"
1765     "Connection: close\n"
1766     "Connection: keep-alive\n",
1767     false
1768   },
1769   { "HTTP/1.1 200 OK\n"
1770     "Connection: keep-alive\n"
1771     "Connection: close\n",
1772     true
1773   },
1774   { "HTTP/1.0 200 OK\n"
1775     "Connection: close\n"
1776     "Connection: keep-alive\n",
1777     false
1778   },
1779   { "HTTP/1.0 200 OK\n"
1780     "Connection: keep-alive\n"
1781     "Connection: close\n",
1782     true
1783   },
1784   // Ignore the Proxy-Connection header if at all possible.
1785   { "HTTP/1.0 200 OK\n"
1786     "Proxy-Connection: keep-alive\n"
1787     "Connection: close\n",
1788     false
1789   },
1790   { "HTTP/1.1 200 OK\n"
1791     "Proxy-Connection: close\n"
1792     "Connection: keep-alive\n",
1793     true
1794   },
1795   // Older versions of Chrome would have ignored Proxy-Connection in this case,
1796   // but it doesn't seem safe.
1797   { "HTTP/1.1 200 OK\n"
1798     "Proxy-Connection: close\n"
1799     "Connection: Transfer-Encoding\n",
1800     false
1801   },
1802 };
1803
1804 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1805                         IsKeepAliveTest,
1806                         testing::ValuesIn(keepalive_tests));
1807
1808 struct HasStrongValidatorsTestData {
1809   const char* headers;
1810   bool expected_result;
1811 };
1812
1813 class HasStrongValidatorsTest
1814     : public HttpResponseHeadersTest,
1815       public ::testing::WithParamInterface<HasStrongValidatorsTestData> {
1816 };
1817
1818 TEST_P(HasStrongValidatorsTest, HasStrongValidators) {
1819   const HasStrongValidatorsTestData test = GetParam();
1820
1821   std::string headers(test.headers);
1822   HeadersToRaw(&headers);
1823   scoped_refptr<net::HttpResponseHeaders> parsed(
1824       new net::HttpResponseHeaders(headers));
1825
1826   EXPECT_EQ(test.expected_result, parsed->HasStrongValidators());
1827 }
1828
1829 const HasStrongValidatorsTestData strong_validators_tests[] = {
1830   { "HTTP/0.9 200 OK",
1831     false
1832   },
1833   { "HTTP/1.0 200 OK\n"
1834     "Date: Wed, 28 Nov 2007 01:40:10 GMT\n"
1835     "Last-Modified: Wed, 28 Nov 2007 00:40:10 GMT\n"
1836     "ETag: \"foo\"\n",
1837     false
1838   },
1839   { "HTTP/1.1 200 OK\n"
1840     "Date: Wed, 28 Nov 2007 01:40:10 GMT\n"
1841     "Last-Modified: Wed, 28 Nov 2007 00:40:10 GMT\n"
1842     "ETag: \"foo\"\n",
1843     true
1844   },
1845   { "HTTP/1.1 200 OK\n"
1846     "Date: Wed, 28 Nov 2007 00:41:10 GMT\n"
1847     "Last-Modified: Wed, 28 Nov 2007 00:40:10 GMT\n",
1848     true
1849   },
1850   { "HTTP/1.1 200 OK\n"
1851     "Date: Wed, 28 Nov 2007 00:41:09 GMT\n"
1852     "Last-Modified: Wed, 28 Nov 2007 00:40:10 GMT\n",
1853     false
1854   },
1855   { "HTTP/1.1 200 OK\n"
1856     "ETag: \"foo\"\n",
1857     true
1858   },
1859   // This is not really a weak etag:
1860   { "HTTP/1.1 200 OK\n"
1861     "etag: \"w/foo\"\n",
1862     true
1863   },
1864   // This is a weak etag:
1865   { "HTTP/1.1 200 OK\n"
1866     "etag: w/\"foo\"\n",
1867     false
1868   },
1869   { "HTTP/1.1 200 OK\n"
1870     "etag:    W  /   \"foo\"\n",
1871     false
1872   }
1873 };
1874
1875 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1876                         HasStrongValidatorsTest,
1877                         testing::ValuesIn(strong_validators_tests));
1878
1879 TEST(HttpResponseHeadersTest, GetStatusText) {
1880   std::string headers("HTTP/1.1 404 Not Found");
1881   HeadersToRaw(&headers);
1882     scoped_refptr<net::HttpResponseHeaders> parsed(
1883         new net::HttpResponseHeaders(headers));
1884   EXPECT_EQ(std::string("Not Found"), parsed->GetStatusText());
1885 }
1886
1887 TEST(HttpResponseHeadersTest, GetStatusTextMissing) {
1888   std::string headers("HTTP/1.1 404");
1889   HeadersToRaw(&headers);
1890     scoped_refptr<net::HttpResponseHeaders> parsed(
1891         new net::HttpResponseHeaders(headers));
1892   // Since the status line gets normalized, we have OK.
1893   EXPECT_EQ(std::string("OK"), parsed->GetStatusText());
1894 }
1895
1896 TEST(HttpResponseHeadersTest, GetStatusTextMultiSpace) {
1897   std::string headers("HTTP/1.0     404     Not   Found");
1898   HeadersToRaw(&headers);
1899     scoped_refptr<net::HttpResponseHeaders> parsed(
1900         new net::HttpResponseHeaders(headers));
1901   EXPECT_EQ(std::string("Not   Found"), parsed->GetStatusText());
1902 }
1903
1904 TEST(HttpResponseHeadersTest, GetStatusBadStatusLine) {
1905   std::string headers("Foo bar.");
1906   HeadersToRaw(&headers);
1907     scoped_refptr<net::HttpResponseHeaders> parsed(
1908         new net::HttpResponseHeaders(headers));
1909   // The bad status line would have gotten rewritten as
1910   // HTTP/1.0 200 OK.
1911   EXPECT_EQ(std::string("OK"), parsed->GetStatusText());
1912 }
1913
1914 struct AddHeaderTestData {
1915   const char* orig_headers;
1916   const char* new_header;
1917   const char* expected_headers;
1918 };
1919
1920 class AddHeaderTest
1921     : public HttpResponseHeadersTest,
1922       public ::testing::WithParamInterface<AddHeaderTestData> {
1923 };
1924
1925 TEST_P(AddHeaderTest, AddHeader) {
1926   const AddHeaderTestData test = GetParam();
1927
1928   std::string orig_headers(test.orig_headers);
1929   HeadersToRaw(&orig_headers);
1930   scoped_refptr<net::HttpResponseHeaders> parsed(
1931       new net::HttpResponseHeaders(orig_headers));
1932
1933   std::string new_header(test.new_header);
1934   parsed->AddHeader(new_header);
1935
1936   std::string resulting_headers;
1937   parsed->GetNormalizedHeaders(&resulting_headers);
1938   EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
1939 }
1940
1941 const AddHeaderTestData add_header_tests[] = {
1942   { "HTTP/1.1 200 OK\n"
1943     "connection: keep-alive\n"
1944     "Cache-control: max-age=10000\n",
1945
1946     "Content-Length: 450",
1947
1948     "HTTP/1.1 200 OK\n"
1949     "connection: keep-alive\n"
1950     "Cache-control: max-age=10000\n"
1951     "Content-Length: 450\n"
1952   },
1953   { "HTTP/1.1 200 OK\n"
1954     "connection: keep-alive\n"
1955     "Cache-control: max-age=10000    \n",
1956
1957     "Content-Length: 450  ",
1958
1959     "HTTP/1.1 200 OK\n"
1960     "connection: keep-alive\n"
1961     "Cache-control: max-age=10000\n"
1962     "Content-Length: 450\n"
1963   },
1964 };
1965
1966 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
1967                         AddHeaderTest,
1968                         testing::ValuesIn(add_header_tests));
1969
1970 struct RemoveHeaderTestData {
1971   const char* orig_headers;
1972   const char* to_remove;
1973   const char* expected_headers;
1974 };
1975
1976 class RemoveHeaderTest
1977     : public HttpResponseHeadersTest,
1978       public ::testing::WithParamInterface<RemoveHeaderTestData> {
1979 };
1980
1981 TEST_P(RemoveHeaderTest, RemoveHeader) {
1982   const RemoveHeaderTestData test = GetParam();
1983
1984   std::string orig_headers(test.orig_headers);
1985   HeadersToRaw(&orig_headers);
1986   scoped_refptr<net::HttpResponseHeaders> parsed(
1987       new net::HttpResponseHeaders(orig_headers));
1988
1989   std::string name(test.to_remove);
1990   parsed->RemoveHeader(name);
1991
1992   std::string resulting_headers;
1993   parsed->GetNormalizedHeaders(&resulting_headers);
1994   EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
1995 }
1996
1997 const RemoveHeaderTestData remove_header_tests[] = {
1998   { "HTTP/1.1 200 OK\n"
1999     "connection: keep-alive\n"
2000     "Cache-control: max-age=10000\n"
2001     "Content-Length: 450\n",
2002
2003     "Content-Length",
2004
2005     "HTTP/1.1 200 OK\n"
2006     "connection: keep-alive\n"
2007     "Cache-control: max-age=10000\n"
2008   },
2009   { "HTTP/1.1 200 OK\n"
2010     "connection: keep-alive  \n"
2011     "Content-Length  : 450  \n"
2012     "Cache-control: max-age=10000\n",
2013
2014     "Content-Length",
2015
2016     "HTTP/1.1 200 OK\n"
2017     "connection: keep-alive\n"
2018     "Cache-control: max-age=10000\n"
2019   },
2020 };
2021
2022 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
2023                         RemoveHeaderTest,
2024                         testing::ValuesIn(remove_header_tests));
2025
2026 struct RemoveIndividualHeaderTestData {
2027   const char* orig_headers;
2028   const char* to_remove_name;
2029   const char* to_remove_value;
2030   const char* expected_headers;
2031 };
2032
2033 class RemoveIndividualHeaderTest
2034     : public HttpResponseHeadersTest,
2035       public ::testing::WithParamInterface<RemoveIndividualHeaderTestData> {
2036 };
2037
2038 TEST_P(RemoveIndividualHeaderTest, RemoveIndividualHeader) {
2039   const RemoveIndividualHeaderTestData test = GetParam();
2040
2041   std::string orig_headers(test.orig_headers);
2042   HeadersToRaw(&orig_headers);
2043   scoped_refptr<net::HttpResponseHeaders> parsed(
2044       new net::HttpResponseHeaders(orig_headers));
2045
2046   std::string name(test.to_remove_name);
2047   std::string value(test.to_remove_value);
2048   parsed->RemoveHeaderLine(name, value);
2049
2050   std::string resulting_headers;
2051   parsed->GetNormalizedHeaders(&resulting_headers);
2052   EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
2053 }
2054
2055 const RemoveIndividualHeaderTestData remove_individual_header_tests[] = {
2056   { "HTTP/1.1 200 OK\n"
2057     "connection: keep-alive\n"
2058     "Cache-control: max-age=10000\n"
2059     "Content-Length: 450\n",
2060
2061     "Content-Length",
2062
2063     "450",
2064
2065     "HTTP/1.1 200 OK\n"
2066     "connection: keep-alive\n"
2067     "Cache-control: max-age=10000\n"
2068   },
2069   { "HTTP/1.1 200 OK\n"
2070     "connection: keep-alive  \n"
2071     "Content-Length  : 450  \n"
2072     "Cache-control: max-age=10000\n",
2073
2074     "Content-Length",
2075
2076     "450",
2077
2078     "HTTP/1.1 200 OK\n"
2079     "connection: keep-alive\n"
2080     "Cache-control: max-age=10000\n"
2081   },
2082   { "HTTP/1.1 200 OK\n"
2083     "connection: keep-alive  \n"
2084     "Content-Length: 450\n"
2085     "Cache-control: max-age=10000\n",
2086
2087     "Content-Length",  // Matching name.
2088
2089     "999",  // Mismatching value.
2090
2091     "HTTP/1.1 200 OK\n"
2092     "connection: keep-alive\n"
2093     "Content-Length: 450\n"
2094     "Cache-control: max-age=10000\n"
2095   },
2096   { "HTTP/1.1 200 OK\n"
2097     "connection: keep-alive  \n"
2098     "Foo: bar, baz\n"
2099     "Foo: bar\n"
2100     "Cache-control: max-age=10000\n",
2101
2102     "Foo",
2103
2104     "bar, baz",  // Space in value.
2105
2106     "HTTP/1.1 200 OK\n"
2107     "connection: keep-alive\n"
2108     "Foo: bar\n"
2109     "Cache-control: max-age=10000\n"
2110   },
2111   { "HTTP/1.1 200 OK\n"
2112     "connection: keep-alive  \n"
2113     "Foo: bar, baz\n"
2114     "Cache-control: max-age=10000\n",
2115
2116     "Foo",
2117
2118     "baz",  // Only partial match -> ignored.
2119
2120     "HTTP/1.1 200 OK\n"
2121     "connection: keep-alive\n"
2122     "Foo: bar, baz\n"
2123     "Cache-control: max-age=10000\n"
2124   },
2125 };
2126
2127 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
2128                         RemoveIndividualHeaderTest,
2129                         testing::ValuesIn(remove_individual_header_tests));
2130
2131 struct ReplaceStatusTestData {
2132   const char* orig_headers;
2133   const char* new_status;
2134   const char* expected_headers;
2135 };
2136
2137 class ReplaceStatusTest
2138     : public HttpResponseHeadersTest,
2139       public ::testing::WithParamInterface<ReplaceStatusTestData> {
2140 };
2141
2142 TEST_P(ReplaceStatusTest, ReplaceStatus) {
2143   const ReplaceStatusTestData test = GetParam();
2144
2145   std::string orig_headers(test.orig_headers);
2146   HeadersToRaw(&orig_headers);
2147   scoped_refptr<net::HttpResponseHeaders> parsed(
2148       new net::HttpResponseHeaders(orig_headers));
2149
2150   std::string name(test.new_status);
2151   parsed->ReplaceStatusLine(name);
2152
2153   std::string resulting_headers;
2154   parsed->GetNormalizedHeaders(&resulting_headers);
2155   EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
2156 }
2157
2158 const ReplaceStatusTestData replace_status_tests[] = {
2159   { "HTTP/1.1 206 Partial Content\n"
2160     "connection: keep-alive\n"
2161     "Cache-control: max-age=10000\n"
2162     "Content-Length: 450\n",
2163
2164     "HTTP/1.1 200 OK",
2165
2166     "HTTP/1.1 200 OK\n"
2167     "connection: keep-alive\n"
2168     "Cache-control: max-age=10000\n"
2169     "Content-Length: 450\n"
2170   },
2171   { "HTTP/1.1 200 OK\n"
2172     "connection: keep-alive\n",
2173
2174     "HTTP/1.1 304 Not Modified",
2175
2176     "HTTP/1.1 304 Not Modified\n"
2177     "connection: keep-alive\n"
2178   },
2179   { "HTTP/1.1 200 OK\n"
2180     "connection: keep-alive  \n"
2181     "Content-Length  : 450   \n"
2182     "Cache-control: max-age=10000\n",
2183
2184     "HTTP/1//1 304 Not Modified",
2185
2186     "HTTP/1.0 304 Not Modified\n"
2187     "connection: keep-alive\n"
2188     "Content-Length: 450\n"
2189     "Cache-control: max-age=10000\n"
2190   },
2191 };
2192
2193 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
2194                         ReplaceStatusTest,
2195                         testing::ValuesIn(replace_status_tests));
2196
2197 struct UpdateWithNewRangeTestData {
2198   const char* orig_headers;
2199   const char* expected_headers;
2200   const char* expected_headers_with_replaced_status;
2201 };
2202
2203 class UpdateWithNewRangeTest
2204     : public HttpResponseHeadersTest,
2205       public ::testing::WithParamInterface<UpdateWithNewRangeTestData> {
2206 };
2207
2208 TEST_P(UpdateWithNewRangeTest, UpdateWithNewRange) {
2209   const UpdateWithNewRangeTestData test = GetParam();
2210
2211   const net::HttpByteRange range = net::HttpByteRange::Bounded(3, 5);
2212
2213   std::string orig_headers(test.orig_headers);
2214   std::replace(orig_headers.begin(), orig_headers.end(), '\n', '\0');
2215   scoped_refptr<net::HttpResponseHeaders> parsed(
2216       new net::HttpResponseHeaders(orig_headers + '\0'));
2217   int64 content_size = parsed->GetContentLength();
2218   std::string resulting_headers;
2219
2220   // Update headers without replacing status line.
2221   parsed->UpdateWithNewRange(range, content_size, false);
2222   parsed->GetNormalizedHeaders(&resulting_headers);
2223   EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
2224
2225   // Replace status line too.
2226   parsed->UpdateWithNewRange(range, content_size, true);
2227   parsed->GetNormalizedHeaders(&resulting_headers);
2228   EXPECT_EQ(std::string(test.expected_headers_with_replaced_status),
2229             resulting_headers);
2230 }
2231
2232 const UpdateWithNewRangeTestData update_range_tests[] = {
2233   { "HTTP/1.1 200 OK\n"
2234     "Content-Length: 450\n",
2235
2236     "HTTP/1.1 200 OK\n"
2237     "Content-Range: bytes 3-5/450\n"
2238     "Content-Length: 3\n",
2239
2240     "HTTP/1.1 206 Partial Content\n"
2241     "Content-Range: bytes 3-5/450\n"
2242     "Content-Length: 3\n",
2243   },
2244   { "HTTP/1.1 200 OK\n"
2245     "Content-Length: 5\n",
2246
2247     "HTTP/1.1 200 OK\n"
2248     "Content-Range: bytes 3-5/5\n"
2249     "Content-Length: 3\n",
2250
2251     "HTTP/1.1 206 Partial Content\n"
2252     "Content-Range: bytes 3-5/5\n"
2253     "Content-Length: 3\n",
2254   },
2255 };
2256
2257 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
2258                         UpdateWithNewRangeTest,
2259                         testing::ValuesIn(update_range_tests));
2260
2261 TEST(HttpResponseHeadersTest, ToNetLogParamAndBackAgain) {
2262   std::string headers("HTTP/1.1 404\n"
2263                       "Content-Length: 450\n"
2264                       "Connection: keep-alive\n");
2265   HeadersToRaw(&headers);
2266   scoped_refptr<net::HttpResponseHeaders> parsed(
2267       new net::HttpResponseHeaders(headers));
2268
2269   scoped_ptr<base::Value> event_param(
2270       parsed->NetLogCallback(net::NetLog::LOG_ALL_BUT_BYTES));
2271   scoped_refptr<net::HttpResponseHeaders> recreated;
2272
2273   ASSERT_TRUE(net::HttpResponseHeaders::FromNetLogParam(event_param.get(),
2274                                                         &recreated));
2275   ASSERT_TRUE(recreated.get());
2276   EXPECT_EQ(parsed->GetHttpVersion(), recreated->GetHttpVersion());
2277   EXPECT_EQ(parsed->response_code(), recreated->response_code());
2278   EXPECT_EQ(parsed->GetContentLength(), recreated->GetContentLength());
2279   EXPECT_EQ(parsed->IsKeepAlive(), recreated->IsKeepAlive());
2280
2281   std::string normalized_parsed;
2282   parsed->GetNormalizedHeaders(&normalized_parsed);
2283   std::string normalized_recreated;
2284   parsed->GetNormalizedHeaders(&normalized_recreated);
2285   EXPECT_EQ(normalized_parsed, normalized_recreated);
2286 }
2287
2288 TEST_F(HttpResponseHeadersCacheControlTest, AbsentMaxAgeReturnsFalse) {
2289   InitializeHeadersWithCacheControl("nocache");
2290   EXPECT_FALSE(headers()->GetMaxAgeValue(TimeDeltaPointer()));
2291 }
2292
2293 TEST_F(HttpResponseHeadersCacheControlTest, MaxAgeWithNoParameterRejected) {
2294   InitializeHeadersWithCacheControl("max-age=,private");
2295   EXPECT_FALSE(headers()->GetMaxAgeValue(TimeDeltaPointer()));
2296 }
2297
2298 TEST_F(HttpResponseHeadersCacheControlTest, MaxAgeWithSpaceParameterRejected) {
2299   InitializeHeadersWithCacheControl("max-age= ,private");
2300   EXPECT_FALSE(headers()->GetMaxAgeValue(TimeDeltaPointer()));
2301 }
2302
2303 TEST_F(HttpResponseHeadersCacheControlTest,
2304        MaxAgeWithSpaceBeforeEqualsIsRejected) {
2305   InitializeHeadersWithCacheControl("max-age = 7");
2306   EXPECT_FALSE(headers()->GetMaxAgeValue(TimeDeltaPointer()));
2307 }
2308
2309 TEST_F(HttpResponseHeadersCacheControlTest, MaxAgeFirstMatchUsed) {
2310   InitializeHeadersWithCacheControl("max-age=10, max-age=20");
2311   EXPECT_EQ(TimeDelta::FromSeconds(10), GetMaxAgeValue());
2312 }
2313
2314 TEST_F(HttpResponseHeadersCacheControlTest, MaxAgeBogusFirstMatchUsed) {
2315   // "max-age10" isn't parsed as "max-age"; "max-age=now" is parsed as
2316   // "max-age=0" and so "max-age=20" is not used.
2317   InitializeHeadersWithCacheControl("max-age10, max-age=now, max-age=20");
2318   EXPECT_EQ(TimeDelta::FromSeconds(0), GetMaxAgeValue());
2319 }
2320
2321 TEST_F(HttpResponseHeadersCacheControlTest, MaxAgeCaseInsensitive) {
2322   InitializeHeadersWithCacheControl("Max-aGe=15");
2323   EXPECT_EQ(TimeDelta::FromSeconds(15), GetMaxAgeValue());
2324 }
2325
2326 struct MaxAgeTestData {
2327   const char* max_age_string;
2328   const int64 expected_seconds;
2329 };
2330
2331 class MaxAgeEdgeCasesTest
2332     : public HttpResponseHeadersCacheControlTest,
2333       public ::testing::WithParamInterface<MaxAgeTestData> {
2334 };
2335
2336 TEST_P(MaxAgeEdgeCasesTest, MaxAgeEdgeCases) {
2337   const MaxAgeTestData test = GetParam();
2338
2339   std::string max_age = "max-age=";
2340   InitializeHeadersWithCacheControl(
2341       (max_age + test.max_age_string).c_str());
2342   EXPECT_EQ(test.expected_seconds, GetMaxAgeValue().InSeconds())
2343       << " for max-age=" << test.max_age_string;
2344 }
2345
2346 const MaxAgeTestData max_age_tests[] = {
2347   {" 1 ", 1},    // Spaces are ignored.
2348   {"-1", -1},    // Negative numbers are passed through.
2349   {"--1", 0},    // Leading junk gives 0.
2350   {"2s", 2},     // Trailing junk is ignored.
2351   {"3 days", 3},
2352   {"'4'", 0},    // Single quotes don't work.
2353   {"\"5\"", 0},  // Double quotes don't work.
2354   {"0x6", 0},    // Hex not parsed as hex.
2355   {"7F", 7},     // Hex without 0x still not parsed as hex.
2356   {"010", 10},   // Octal not parsed as octal.
2357   {"9223372036854", 9223372036854},
2358   //  {"9223372036855", -9223372036854},  // Undefined behaviour.
2359   //  {"9223372036854775806", -2},        // Undefined behaviour.
2360   {"9223372036854775807", 9223372036854775807},
2361   {"20000000000000000000",
2362   std::numeric_limits<int64>::max()},  // Overflow int64.
2363 };
2364
2365 INSTANTIATE_TEST_CASE_P(HttpResponseHeadersCacheControl,
2366                         MaxAgeEdgeCasesTest,
2367                         testing::ValuesIn(max_age_tests));
2368
2369 TEST_F(HttpResponseHeadersCacheControlTest,
2370        AbsentStaleWhileRevalidateReturnsFalse) {
2371   InitializeHeadersWithCacheControl("max-age=3600");
2372   EXPECT_FALSE(headers()->GetStaleWhileRevalidateValue(TimeDeltaPointer()));
2373 }
2374
2375 TEST_F(HttpResponseHeadersCacheControlTest,
2376        StaleWhileRevalidateWithoutValueRejected) {
2377   InitializeHeadersWithCacheControl("max-age=3600,stale-while-revalidate=");
2378   EXPECT_FALSE(headers()->GetStaleWhileRevalidateValue(TimeDeltaPointer()));
2379 }
2380
2381 TEST_F(HttpResponseHeadersCacheControlTest,
2382        StaleWhileRevalidateWithInvalidValueTreatedAsZero) {
2383   InitializeHeadersWithCacheControl("max-age=3600,stale-while-revalidate=true");
2384   EXPECT_EQ(TimeDelta(), GetStaleWhileRevalidateValue());
2385 }
2386
2387 TEST_F(HttpResponseHeadersCacheControlTest, StaleWhileRevalidateValueReturned) {
2388   InitializeHeadersWithCacheControl("max-age=3600,stale-while-revalidate=7200");
2389   EXPECT_EQ(TimeDelta::FromSeconds(7200), GetStaleWhileRevalidateValue());
2390 }
2391
2392 TEST_F(HttpResponseHeadersCacheControlTest,
2393        FirstStaleWhileRevalidateValueUsed) {
2394   InitializeHeadersWithCacheControl(
2395       "stale-while-revalidate=1,stale-while-revalidate=7200");
2396   EXPECT_EQ(TimeDelta::FromSeconds(1), GetStaleWhileRevalidateValue());
2397 }
2398
2399 } // end namespace