Update from https://crrev.com/303153

net/http/http_util_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 854 matching lines @@
                   ranges[j].first_byte_position());
         EXPECT_EQ(tests[i].expected_ranges[j].expected_last_byte_position,
                   ranges[j].last_byte_position());
         EXPECT_EQ(tests[i].expected_ranges[j].expected_suffix_length,
                   ranges[j].suffix_length());
       }
     }
   }
 }
 
+TEST(HttpUtilTest, ParseRetryAfterHeader) {
+  base::Time::Exploded now_exploded = { 2014, 11, -1, 5, 22, 39, 30, 0 };
+  base::Time now = base::Time::FromUTCExploded(now_exploded);
+
+  base::Time::Exploded later_exploded = { 2015, 1, -1, 1, 12, 34, 56, 0 };
+  base::Time later = base::Time::FromUTCExploded(later_exploded);
+
+  const struct {
+    const char* retry_after_string;
+    bool expected_return_value;
+    base::TimeDelta expected_retry_after;
+  } tests[] = {
+    { "", false, base::TimeDelta() },
+    { "-3", false, base::TimeDelta() },
+    { "-2", false, base::TimeDelta() },
+    { "-1", false, base::TimeDelta() },
+    { "0", true, base::TimeDelta::FromSeconds(0) },
+    { "1", true, base::TimeDelta::FromSeconds(1) },
+    { "2", true, base::TimeDelta::FromSeconds(2) },
+    { "3", true, base::TimeDelta::FromSeconds(3) },
+    { "60", true, base::TimeDelta::FromSeconds(60) },
+    { "3600", true, base::TimeDelta::FromSeconds(3600) },
+    { "86400", true, base::TimeDelta::FromSeconds(86400) },
+    { "Thu, 1 Jan 2015 12:34:56 GMT", true, later - now },
+    { "Mon, 1 Jan 1900 12:34:56 GMT", false, base::TimeDelta() }
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    base::TimeDelta retry_after;
+    bool return_value = HttpUtil::ParseRetryAfterHeader(
+        tests[i].retry_after_string, now, &retry_after);
+    EXPECT_EQ(tests[i].expected_return_value, return_value)
+        << "Test case " << i << ": expected " << tests[i].expected_return_value
+        << " but got " << return_value << ".";
+    if (tests[i].expected_return_value && return_value) {
+      EXPECT_EQ(tests[i].expected_retry_after, retry_after)
+          << "Test case " << i << ": expected "
+          << tests[i].expected_retry_after.InSeconds() << "s but got "
+          << retry_after.InSeconds() << "s.";
+    }
+  }
+}
+
 namespace {
 void CheckCurrentNameValuePair(HttpUtil::NameValuePairsIterator* parser,
                                bool expect_valid,
                                std::string expected_name,
                                std::string expected_value) {
   ASSERT_EQ(expect_valid, parser->valid());
   if (!expect_valid) {
     return;
   }
 
@@ skipping 179 matching lines @@
 TEST(HttpUtilTest, NameValuePairsIteratorMissingEndQuote) {
   std::string data = "name='value";
   HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';');
   EXPECT_TRUE(parser.valid());
 
   ASSERT_NO_FATAL_FAILURE(
       CheckNextNameValuePair(&parser, true, true, "name", "value"));
   ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair(
       &parser, false, true, std::string(), std::string()));
 }