Convert implicit scoped_refptr constructor calls to explicit ones, part 1

net/http/http_response_headers_unittest.cc

 // Copyright (c) 2006-2009 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"
@@ skipping 33 matching lines @@
   if (!headers->empty())
     *headers += '\0';
 }
 
 void TestCommon(const TestData& test) {
   string raw_headers(test.raw_headers);
   HeadersToRaw(&raw_headers);
   string expected_headers(test.expected_headers);
 
   string headers;
-  scoped_refptr<HttpResponseHeaders> parsed =
-      new HttpResponseHeaders(raw_headers);
+  scoped_refptr<HttpResponseHeaders> parsed(
+      new 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 208 matching lines @@
   };
   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<HttpResponseHeaders> parsed(new 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<HttpResponseHeaders> parsed1(
+        new HttpResponseHeaders(headers));
 
     Pickle pickle;
     parsed1->Persist(&pickle, tests[i].options);
 
     void* iter = NULL;
-    scoped_refptr<HttpResponseHeaders> parsed2 =
-        new HttpResponseHeaders(pickle, &iter);
+    scoped_refptr<HttpResponseHeaders> parsed2(
+        new HttpResponseHeaders(pickle, &iter));
 
     std::string h2;
     parsed2->GetNormalizedHeaders(&h2);
     EXPECT_EQ(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<HttpResponseHeaders> parsed(new 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<HttpResponseHeaders> parsed(new 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<HttpResponseHeaders> parsed(new 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 123 matching lines @@
     { "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);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new 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 129 matching lines @@
     // 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);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     string headers(tests[i].headers);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new 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 42 matching lines @@
 
       "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);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(orig_headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new HttpResponseHeaders(orig_headers));
 
     string new_headers(tests[i].new_headers);
     HeadersToRaw(&new_headers);
-    scoped_refptr<HttpResponseHeaders> new_parsed =
-        new HttpResponseHeaders(new_headers);
+    scoped_refptr<HttpResponseHeaders> new_parsed(
+        new HttpResponseHeaders(new_headers));
 
     parsed->Update(*new_parsed);
 
     string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
     EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
   }
 }
 
 TEST(HttpResponseHeadersTest, EnumerateHeaderLines) {
@@ skipping 19 matching lines @@
     },
     { "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);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new HttpResponseHeaders(headers));
 
     string name, value, lines;
 
     void* iter = NULL;
     while (parsed->EnumerateHeaderLines(&iter, &name, &value)) {
       lines.append(name);
       lines.append(": ");
       lines.append(value);
       lines.append("\n");
     }
@@ skipping 62 matching lines @@
     },
     { "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);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new 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 64 matching lines @@
       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);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new 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 229 matching lines @@
       "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);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new 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 60 matching lines @@
       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);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new HttpResponseHeaders(headers));
 
     EXPECT_EQ(tests[i].expected_keep_alive, parsed->IsKeepAlive());
   }
 }
 
 TEST(HttpResponseHeadersTest, HasStrongValidators) {
   const struct {
     const char* headers;
     bool expected_result;
   } tests[] = {
@@ skipping 31 matching lines @@
       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);
     HeadersToRaw(&headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new 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<HttpResponseHeaders> parsed(new 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<HttpResponseHeaders> parsed(new 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<HttpResponseHeaders> parsed(new 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<HttpResponseHeaders> parsed(new 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 18 matching lines @@
       "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);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(orig_headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new HttpResponseHeaders(orig_headers));
 
     string new_header(tests[i].new_header);
     parsed->AddHeader(new_header);
 
     string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
     EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
   }
 }
 
@@ skipping 23 matching lines @@
 
       "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);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(orig_headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new HttpResponseHeaders(orig_headers));
 
     string name(tests[i].to_remove);
     parsed->RemoveHeader(name);
 
     string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
     EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
   }
 }
 
@@ skipping 33 matching lines @@
       "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);
     HeadersToRaw(&orig_headers);
-    scoped_refptr<HttpResponseHeaders> parsed =
-        new HttpResponseHeaders(orig_headers);
+    scoped_refptr<HttpResponseHeaders> parsed(
+        new HttpResponseHeaders(orig_headers));
 
     string name(tests[i].new_status);
     parsed->ReplaceStatusLine(name);
 
     string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
     EXPECT_EQ(string(tests[i].expected_headers), resulting_headers);
   }
 }