Remove "using namespace std" which is illegal per style guide....

net/http/http_response_headers_unittest.cc

-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/pickle.h"
 #include "base/time.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using namespace std;
-using base::Time;
-using net::HttpResponseHeaders;
-using net::HttpVersion;
-
 namespace {
 
 struct TestData {
   const char* raw_headers;
   const char* expected_headers;
   int expected_response_code;
-  HttpVersion expected_parsed_version;
-  HttpVersion expected_version;
+  net::HttpVersion expected_parsed_version;
+  net::HttpVersion expected_version;
 };
 
 struct ContentTypeTestData {
-  const string raw_headers;
-  const string mime_type;
+  const std::string raw_headers;
+  const std::string mime_type;
   const bool has_mimetype;
-  const string charset;
+  const std::string charset;
   const bool has_charset;
-  const string all_content_type;
+  const std::string all_content_type;
 };
 
 class HttpResponseHeadersTest : public testing::Test {
 };
 
 // Transform "normal"-looking headers (\n-separated) to the appropriate
 // input format for ParseRawHeaders (\0-separated).
 void HeadersToRaw(std::string* headers) {
   replace(headers->begin(), headers->end(), '\n', '\0');
   if (!headers->empty())
     *headers += '\0';
 }
 
 void TestCommon(const TestData& test) {
-  string raw_headers(test.raw_headers);
+  std::string raw_headers(test.raw_headers);
   HeadersToRaw(&raw_headers);
-  string expected_headers(test.expected_headers);
+  std::string expected_headers(test.expected_headers);
 
-  string headers;
-  scoped_refptr<HttpResponseHeaders> parsed(
-      new HttpResponseHeaders(raw_headers));
+  std::string headers;
+  scoped_refptr<net::HttpResponseHeaders> parsed(
+      new net::HttpResponseHeaders(raw_headers));
   parsed->GetNormalizedHeaders(&headers);
 
   // Transform to readable output format (so it's easier to see diffs).
   replace(headers.begin(), headers.end(), ' ', '_');
   replace(headers.begin(), headers.end(), '\n', '\\');
   replace(expected_headers.begin(), expected_headers.end(), ' ', '_');
   replace(expected_headers.begin(), expected_headers.end(), '\n', '\\');
 
   EXPECT_EQ(expected_headers, headers);
 
@@ skipping 11 matching lines @@
     "HTTP/1.1    202   Accepted  \n"
     "Content-TYPE  : text/html; charset=utf-8  \n"
     "Set-Cookie: a \n"
     "Set-Cookie:   b \n",
 
     "HTTP/1.1 202 Accepted\n"
     "Content-TYPE: text/html; charset=utf-8\n"
     "Set-Cookie: a, b\n",
 
     202,
-    HttpVersion(1,1),
-    HttpVersion(1,1)
+    net::HttpVersion(1,1),
+    net::HttpVersion(1,1)
   };
   TestCommon(test);
 }
 
 // Check that we normalize headers properly (header name is invalid if starts
 // with LWS).
 TEST(HttpResponseHeadersTest, NormalizeHeadersLeadingWhitespace) {
   TestData test = {
     "HTTP/1.1    202   Accepted  \n"
     // Starts with space -- will be skipped as invalid.
     "  Content-TYPE  : text/html; charset=utf-8  \n"
     "Set-Cookie: a \n"
     "Set-Cookie:   b \n",
 
     "HTTP/1.1 202 Accepted\n"
     "Set-Cookie: a, b\n",
 
     202,
-    HttpVersion(1,1),
-    HttpVersion(1,1)
+    net::HttpVersion(1,1),
+    net::HttpVersion(1,1)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, BlankHeaders) {
   TestData test = {
     "HTTP/1.1 200 OK\n"
     "Header1 :          \n"
     "Header2: \n"
     "Header3:\n"
     "Header4\n"
     "Header5    :\n",
 
     "HTTP/1.1 200 OK\n"
     "Header1: \n"
     "Header2: \n"
     "Header3: \n"
     "Header5: \n",
 
     200,
-    HttpVersion(1,1),
-    HttpVersion(1,1)
+    net::HttpVersion(1,1),
+    net::HttpVersion(1,1)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, NormalizeHeadersVersion) {
   // Don't believe the http/0.9 version if there are headers!
   TestData test = {
     "hTtP/0.9 201\n"
     "Content-TYPE: text/html; charset=utf-8\n",
 
     "HTTP/1.0 201 OK\n"
     "Content-TYPE: text/html; charset=utf-8\n",
 
     201,
-    HttpVersion(0,9),
-    HttpVersion(1,0)
+    net::HttpVersion(0,9),
+    net::HttpVersion(1,0)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, PreserveHttp09) {
   // Accept the HTTP/0.9 version number if there are no headers.
   // This is how HTTP/0.9 responses get constructed from HttpNetworkTransaction.
   TestData test = {
     "hTtP/0.9 200 OK\n",
 
     "HTTP/0.9 200 OK\n",
 
     200,
-    HttpVersion(0,9),
-    HttpVersion(0,9)
+    net::HttpVersion(0,9),
+    net::HttpVersion(0,9)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, NormalizeHeadersMissingOK) {
   TestData test = {
     "HTTP/1.1 201\n"
     "Content-TYPE: text/html; charset=utf-8\n",
 
     "HTTP/1.1 201 OK\n"
     "Content-TYPE: text/html; charset=utf-8\n",
 
     201,
-    HttpVersion(1,1),
-    HttpVersion(1,1)
+    net::HttpVersion(1,1),
+    net::HttpVersion(1,1)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, NormalizeHeadersBadStatus) {
   TestData test = {
     "SCREWED_UP_STATUS_LINE\n"
     "Content-TYPE: text/html; charset=utf-8\n",
 
     "HTTP/1.0 200 OK\n"
     "Content-TYPE: text/html; charset=utf-8\n",
 
     200,
-    HttpVersion(0,0), // Parse error
-    HttpVersion(1,0)
+    net::HttpVersion(0,0), // Parse error
+    net::HttpVersion(1,0)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, NormalizeHeadersEmpty) {
   TestData test = {
     "",
 
     "HTTP/1.0 200 OK\n",
 
     200,
-    HttpVersion(0,0), // Parse Error
-    HttpVersion(1,0)
+    net::HttpVersion(0,0), // Parse Error
+    net::HttpVersion(1,0)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, NormalizeHeadersStartWithColon) {
   TestData test = {
     "HTTP/1.1    202   Accepted  \n"
     "foo: bar\n"
     ": a \n"
     " : b\n"
     "baz: blat \n",
 
     "HTTP/1.1 202 Accepted\n"
     "foo: bar\n"
     "baz: blat\n",
 
     202,
-    HttpVersion(1,1),
-    HttpVersion(1,1)
+    net::HttpVersion(1,1),
+    net::HttpVersion(1,1)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, NormalizeHeadersStartWithColonAtEOL) {
   TestData test = {
     "HTTP/1.1    202   Accepted  \n"
     "foo:   \n"
     "bar:\n"
     "baz: blat \n"
     "zip:\n",
 
     "HTTP/1.1 202 Accepted\n"
     "foo: \n"
     "bar: \n"
     "baz: blat\n"
     "zip: \n",
 
     202,
-    HttpVersion(1,1),
-    HttpVersion(1,1)
+    net::HttpVersion(1,1),
+    net::HttpVersion(1,1)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, NormalizeHeadersOfWhitepace) {
   TestData test = {
     "\n   \n",
 
     "HTTP/1.0 200 OK\n",
 
     200,
-    HttpVersion(0,0),  // Parse error
-    HttpVersion(1,0)
+    net::HttpVersion(0,0),  // Parse error
+    net::HttpVersion(1,0)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, RepeatedSetCookie) {
   TestData test = {
     "HTTP/1.1 200 OK\n"
     "Set-Cookie: x=1\n"
     "Set-Cookie: y=2\n",
 
     "HTTP/1.1 200 OK\n"
     "Set-Cookie: x=1, y=2\n",
 
     200,
-    HttpVersion(1,1),
-    HttpVersion(1,1)
+    net::HttpVersion(1,1),
+    net::HttpVersion(1,1)
   };
   TestCommon(test);
 }
 
 TEST(HttpResponseHeadersTest, GetNormalizedHeader) {
   std::string headers =
       "HTTP/1.1 200 OK\n"
       "Cache-control: private\n"
       "cache-Control: no-store\n";
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+  scoped_refptr<net::HttpResponseHeaders> parsed(
+      new net::HttpResponseHeaders(headers));
 
   std::string value;
   EXPECT_TRUE(parsed->GetNormalizedHeader("cache-control", &value));
   EXPECT_EQ("private, no-store", value);
 }
 
 TEST(HttpResponseHeadersTest, Persist) {
   const struct {
     net::HttpResponseHeaders::PersistOptions options;
     const char* raw_headers;
@@ skipping 146 matching lines @@
 
       "HTTP/1.1 200 OK\n"
       "Content-Length: 450\n"
       "Content-Encoding: gzip\n"
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers = tests[i].raw_headers;
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed1(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed1(
+        new net::HttpResponseHeaders(headers));
 
     Pickle pickle;
     parsed1->Persist(&pickle, tests[i].options);
 
     void* iter = NULL;
-    scoped_refptr<HttpResponseHeaders> parsed2(
-        new HttpResponseHeaders(pickle, &iter));
+    scoped_refptr<net::HttpResponseHeaders> parsed2(
+        new net::HttpResponseHeaders(pickle, &iter));
 
     std::string h2;
     parsed2->GetNormalizedHeaders(&h2);
-    EXPECT_EQ(string(tests[i].expected_headers), h2);
+    EXPECT_EQ(std::string(tests[i].expected_headers), h2);
   }
 }
 
 TEST(HttpResponseHeadersTest, EnumerateHeader_Coalesced) {
   // Ensure that commas in quoted strings are not regarded as value separators.
   // Ensure that whitespace following a value is trimmed properly
   std::string headers =
       "HTTP/1.1 200 OK\n"
       "Cache-control:private , no-cache=\"set-cookie,server\" \n"
       "cache-Control: no-store\n";
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+  scoped_refptr<net::HttpResponseHeaders> parsed(
+      new net::HttpResponseHeaders(headers));
 
   void* iter = NULL;
   std::string value;
   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "cache-control", &value));
   EXPECT_EQ("private", value);
   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "cache-control", &value));
   EXPECT_EQ("no-cache=\"set-cookie,server\"", value);
   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "cache-control", &value));
   EXPECT_EQ("no-store", value);
   EXPECT_FALSE(parsed->EnumerateHeader(&iter, "cache-control", &value));
 }
 
 TEST(HttpResponseHeadersTest, EnumerateHeader_Challenge) {
   // Even though WWW-Authenticate has commas, it should not be treated as
   // coalesced values.
   std::string headers =
       "HTTP/1.1 401 OK\n"
       "WWW-Authenticate:Digest realm=foobar, nonce=x, domain=y\n"
       "WWW-Authenticate:Basic realm=quatar\n";
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+  scoped_refptr<net::HttpResponseHeaders> parsed(
+      new net::HttpResponseHeaders(headers));
 
   void* iter = NULL;
   std::string value;
   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "WWW-Authenticate", &value));
   EXPECT_EQ("Digest realm=foobar, nonce=x, domain=y", value);
   EXPECT_TRUE(parsed->EnumerateHeader(&iter, "WWW-Authenticate", &value));
   EXPECT_EQ("Basic realm=quatar", value);
   EXPECT_FALSE(parsed->EnumerateHeader(&iter, "WWW-Authenticate", &value));
 }
 
 TEST(HttpResponseHeadersTest, EnumerateHeader_DateValued) {
   // The comma in a date valued header should not be treated as a
   // field-value separator
   std::string headers =
       "HTTP/1.1 200 OK\n"
       "Date: Tue, 07 Aug 2007 23:10:55 GMT\n"
       "Last-Modified: Wed, 01 Aug 2007 23:23:45 GMT\n";
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+  scoped_refptr<net::HttpResponseHeaders> parsed(
+      new net::HttpResponseHeaders(headers));
 
   std::string value;
   EXPECT_TRUE(parsed->EnumerateHeader(NULL, "date", &value));
   EXPECT_EQ("Tue, 07 Aug 2007 23:10:55 GMT", value);
   EXPECT_TRUE(parsed->EnumerateHeader(NULL, "last-modified", &value));
   EXPECT_EQ("Wed, 01 Aug 2007 23:23:45 GMT", value);
 }
 
 TEST(HttpResponseHeadersTest, GetMimeType) {
   const ContentTypeTestData tests[] = {
@@ skipping 121 matching lines @@
       "texthtml" },
     // Invalid media type: */*
     { "HTTP/1.1 200 OK\n"
       "Content-type: */*\n",
       "", false,
       "", false,
       "*/*" },
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    string headers(tests[i].raw_headers);
+    std::string headers(tests[i].raw_headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
     std::string value;
     EXPECT_EQ(tests[i].has_mimetype, parsed->GetMimeType(&value));
     EXPECT_EQ(tests[i].mime_type, value);
     value.clear();
     EXPECT_EQ(tests[i].has_charset, parsed->GetCharset(&value));
     EXPECT_EQ(tests[i].charset, value);
     EXPECT_TRUE(parsed->GetNormalizedHeader("content-type", &value));
     EXPECT_EQ(tests[i].all_content_type, value);
   }
@@ skipping 121 matching lines @@
     // pragma: no-cache overrides last-modified heuristic
     { "HTTP/1.1 200 OK\n"
       "date: Wed, 28 Nov 2007 00:40:11 GMT\n"
       "last-modified: Wed, 27 Nov 2007 08:00:00 GMT\n"
       "pragma: no-cache\n"
       "\n",
       true
     },
     // TODO(darin): add many many more tests here
   };
-  Time request_time, response_time, current_time;
-  Time::FromString(L"Wed, 28 Nov 2007 00:40:09 GMT", &request_time);
-  Time::FromString(L"Wed, 28 Nov 2007 00:40:12 GMT", &response_time);
-  Time::FromString(L"Wed, 28 Nov 2007 00:45:20 GMT", &current_time);
+  base::Time request_time, response_time, current_time;
+  base::Time::FromString(L"Wed, 28 Nov 2007 00:40:09 GMT", &request_time);
+  base::Time::FromString(L"Wed, 28 Nov 2007 00:40:12 GMT", &response_time);
+  base::Time::FromString(L"Wed, 28 Nov 2007 00:45:20 GMT", &current_time);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string headers(tests[i].headers);
+    std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
     bool requires_validation =
         parsed->RequiresValidation(request_time, response_time, current_time);
     EXPECT_EQ(tests[i].requires_validation, requires_validation);
   }
 }
 
 TEST(HttpResponseHeadersTest, Update) {
   const struct {
     const char* orig_headers;
@@ skipping 40 matching lines @@
       "connection: keep-alive\n"
       "Cache-control:      max-age=10001   \n",
 
       "HTTP/1.1 200 OK\n"
       "Cache-control: max-age=10001\n"
       "Content-Length: 450\n"
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string orig_headers(tests[i].orig_headers);
+    std::string orig_headers(tests[i].orig_headers);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(orig_headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(orig_headers));
 
-    string new_headers(tests[i].new_headers);
+    std::string new_headers(tests[i].new_headers);
     HeadersToRaw(&new_headers);
-    scoped_refptr<HttpResponseHeaders> new_parsed(
-        new HttpResponseHeaders(new_headers));
+    scoped_refptr<net::HttpResponseHeaders> new_parsed(
+        new net::HttpResponseHeaders(new_headers));
 
     parsed->Update(*new_parsed);
 
-    string resulting_headers;
+    std::string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
-    EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
+    EXPECT_EQ(std::string(tests[i].expected_headers), resulting_headers);
   }
 }
 
 TEST(HttpResponseHeadersTest, EnumerateHeaderLines) {
   const struct {
     const char* headers;
     const char* expected_lines;
   } tests[] = {
     { "HTTP/1.1 200 OK\n",
 
@@ skipping 11 matching lines @@
 
       "Foo: 1\nBar: 2\nFoo: 3\n"
     },
     { "HTTP/1.1 200 OK\n"
       "Foo: 1, 2, 3\n",
 
       "Foo: 1, 2, 3\n"
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string headers(tests[i].headers);
+    std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
-    string name, value, lines;
+    std::string name, value, lines;
 
     void* iter = NULL;
     while (parsed->EnumerateHeaderLines(&iter, &name, &value)) {
       lines.append(name);
       lines.append(": ");
       lines.append(value);
       lines.append("\n");
     }
 
-    EXPECT_EQ(string(tests[i].expected_lines), lines);
+    EXPECT_EQ(std::string(tests[i].expected_lines), lines);
   }
 }
 
 TEST(HttpResponseHeadersTest, IsRedirect) {
   const struct {
     const char* headers;
     const char* location;
     bool is_redirect;
   } tests[] = {
     { "HTTP/1.1 200 OK\n",
@@ skipping 48 matching lines @@
       "http://foo/bar?key=%82@%BD%C4",
       true
     },
     { "HTTP/1.1 301 Moved\n"
       "Location: http://foo/bar?key=\x83\x5C\x82\x5D\xCB\xD7\n",
       "http://foo/bar?key=%83\\%82]%CB%D7",
       true
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string headers(tests[i].headers);
+    std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
     std::string location;
     EXPECT_EQ(parsed->IsRedirect(&location), tests[i].is_redirect);
     EXPECT_EQ(location, tests[i].location);
   }
 }
 
 TEST(HttpResponseHeadersTest, GetContentLength) {
   const struct {
     const char* headers;
@@ skipping 62 matching lines @@
     { "HTTP/1.1 200 OK\n"
       "cOnTeNt-LENgth: 33\n",
       33
     },
     { "HTTP/1.1 200 OK\n"
       "Content-Length: 34\r\n",
       -1
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string headers(tests[i].headers);
+    std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
     EXPECT_EQ(tests[i].expected_len, parsed->GetContentLength());
   }
 }
 
 TEST(HttpResponseHeaders, GetContentRange) {
   const struct {
     const char* headers;
     bool expected_return_value;
     int64 expected_first_byte_position;
@@ skipping 227 matching lines @@
     },
     { "HTTP/1.1 206 Partial Content\n"
       "Content-Range: bytes -123 - -1/100",
       false,
       -1,
       -1,
       -1
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string headers(tests[i].headers);
+    std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
     int64 first_byte_position;
     int64 last_byte_position;
     int64 instance_size;
     bool return_value = parsed->GetContentRange(&first_byte_position,
                                                 &last_byte_position,
                                                 &instance_size);
     EXPECT_EQ(tests[i].expected_return_value, return_value);
     EXPECT_EQ(tests[i].expected_first_byte_position, first_byte_position);
     EXPECT_EQ(tests[i].expected_last_byte_position, last_byte_position);
@@ skipping 58 matching lines @@
     { "HTTP/1.1 200 OK\n"
       "proxy-connection: close\n",
       false
     },
     { "HTTP/1.1 200 OK\n"
       "proxy-connection: keep-alive\n",
       true
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string headers(tests[i].headers);
+    std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
     EXPECT_EQ(tests[i].expected_keep_alive, parsed->IsKeepAlive());
   }
 }
 
 TEST(HttpResponseHeadersTest, HasStrongValidators) {
   const struct {
     const char* headers;
     bool expected_result;
   } tests[] = {
@@ skipping 29 matching lines @@
     { "HTTP/1.1 200 OK\n"
       "etag: w/\"foo\"\n",
       false
     },
     { "HTTP/1.1 200 OK\n"
       "etag:    W  /   \"foo\"\n",
       false
     }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string headers(tests[i].headers);
+    std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
 
     EXPECT_EQ(tests[i].expected_result, parsed->HasStrongValidators()) <<
         "Failed test case " << i;
   }
 }
 
 TEST(HttpResponseHeadersTest, GetStatusText) {
   std::string headers("HTTP/1.1 404 Not Found");
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
   EXPECT_EQ(std::string("Not Found"), parsed->GetStatusText());
 }
 
 TEST(HttpResponseHeadersTest, GetStatusTextMissing) {
   std::string headers("HTTP/1.1 404");
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
   // Since the status line gets normalized, we have OK
   EXPECT_EQ(std::string("OK"), parsed->GetStatusText());
 }
 
 TEST(HttpResponseHeadersTest, GetStatusTextMultiSpace) {
   std::string headers("HTTP/1.0     404     Not   Found");
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
   EXPECT_EQ(std::string("Not   Found"), parsed->GetStatusText());
 }
 
 TEST(HttpResponseHeadersTest, GetStatusBadStatusLine) {
   std::string headers("Foo bar.");
   HeadersToRaw(&headers);
-  scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(headers));
   // The bad status line would have gotten rewritten as
   // HTTP/1.0 200 OK.
   EXPECT_EQ(std::string("OK"), parsed->GetStatusText());
 }
 
 TEST(HttpResponseHeadersTest, AddHeader) {
   const struct {
     const char* orig_headers;
     const char* new_header;
     const char* expected_headers;
@@ skipping 16 matching lines @@
       "Content-Length: 450  ",
 
       "HTTP/1.1 200 OK\n"
       "connection: keep-alive\n"
       "Cache-control: max-age=10000\n"
       "Content-Length: 450\n"
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string orig_headers(tests[i].orig_headers);
+    std::string orig_headers(tests[i].orig_headers);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(orig_headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(orig_headers));
 
-    string new_header(tests[i].new_header);
+    std::string new_header(tests[i].new_header);
     parsed->AddHeader(new_header);
 
-    string resulting_headers;
+    std::string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
-    EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
+    EXPECT_EQ(std::string(tests[i].expected_headers), resulting_headers);
   }
 }
 
 TEST(HttpResponseHeadersTest, RemoveHeader) {
   const struct {
     const char* orig_headers;
     const char* to_remove;
     const char* expected_headers;
   } tests[] = {
     { "HTTP/1.1 200 OK\n"
@@ skipping 14 matching lines @@
 
       "Content-Length",
 
       "HTTP/1.1 200 OK\n"
       "connection: keep-alive\n"
       "Cache-control: max-age=10000\n"
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string orig_headers(tests[i].orig_headers);
+    std::string orig_headers(tests[i].orig_headers);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(orig_headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(orig_headers));
 
-    string name(tests[i].to_remove);
+    std::string name(tests[i].to_remove);
     parsed->RemoveHeader(name);
 
-    string resulting_headers;
+    std::string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
-    EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
+    EXPECT_EQ(std::string(tests[i].expected_headers), resulting_headers);
   }
 }
 
 TEST(HttpResponseHeadersTest, ReplaceStatus) {
   const struct {
     const char* orig_headers;
     const char* new_status;
     const char* expected_headers;
   } tests[] = {
     { "HTTP/1.1 206 Partial Content\n"
@@ skipping 24 matching lines @@
       "HTTP/1//1 304 Not Modified",
 
       "HTTP/1.0 304 Not Modified\n"
       "connection: keep-alive\n"
       "Content-Length: 450\n"
       "Cache-control: max-age=10000\n"
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    string orig_headers(tests[i].orig_headers);
+    std::string orig_headers(tests[i].orig_headers);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed(
-        new HttpResponseHeaders(orig_headers));
+    scoped_refptr<net::HttpResponseHeaders> parsed(
+        new net::HttpResponseHeaders(orig_headers));
 
-    string name(tests[i].new_status);
+    std::string name(tests[i].new_status);
     parsed->ReplaceStatusLine(name);
 
-    string resulting_headers;
+    std::string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
-    EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
+    EXPECT_EQ(std::string(tests[i].expected_headers), resulting_headers);
   }
 }