Remove implicit conversions from scoped_refptr to T* in components/data_reduction_proxy/

components/data_reduction_proxy/common/data_reduction_proxy_headers_unittest.cc

 // Copyright 2014 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 "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
 
 #include <vector>
 
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
@@ skipping 94 matching lines @@
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     std::string action_value;
     bool has_action_key = GetDataReductionProxyActionValue(
-        parsed, tests[i].action_key, &action_value);
+        parsed.get(), tests[i].action_key, &action_value);
     EXPECT_EQ(tests[i].expected_result, has_action_key);
     if (has_action_key) {
       EXPECT_EQ(tests[i].expected_action_value, action_value);
     }
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest, GetProxyBypassInfo) {
   const struct {
      const char* headers;
@@ skipping 228 matching lines @@
       false,
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     DataReductionProxyInfo data_reduction_proxy_info;
-    EXPECT_EQ(tests[i].expected_result,
-              ParseHeadersAndSetProxyInfo(parsed, &data_reduction_proxy_info));
+    EXPECT_EQ(
+        tests[i].expected_result,
+        ParseHeadersAndSetProxyInfo(parsed.get(), &data_reduction_proxy_info));
     EXPECT_EQ(tests[i].expected_retry_delay,
               data_reduction_proxy_info.bypass_duration.InSeconds());
     EXPECT_EQ(tests[i].expected_bypass_all,
               data_reduction_proxy_info.bypass_all);
     EXPECT_EQ(tests[i].expected_mark_proxies_as_bad,
               data_reduction_proxy_info.mark_proxies_as_bad);
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest, ParseHeadersAndSetProxyInfo) {
   std::string headers =
       "HTTP/1.1 200 OK\n"
       "connection: keep-alive\n"
       "Chrome-Proxy: bypass=0\n"
       "Content-Length: 999\n";
   HeadersToRaw(&headers);
   scoped_refptr<net::HttpResponseHeaders> parsed(
       new net::HttpResponseHeaders(headers));
 
   DataReductionProxyInfo data_reduction_proxy_info;
-  EXPECT_TRUE(ParseHeadersAndSetProxyInfo(parsed, &data_reduction_proxy_info));
+  EXPECT_TRUE(
+      ParseHeadersAndSetProxyInfo(parsed.get(), &data_reduction_proxy_info));
   EXPECT_LE(60, data_reduction_proxy_info.bypass_duration.InSeconds());
   EXPECT_GE(5 * 60, data_reduction_proxy_info.bypass_duration.InSeconds());
   EXPECT_FALSE(data_reduction_proxy_info.bypass_all);
 }
 
 TEST_F(DataReductionProxyHeadersTest, HasDataReductionProxyViaHeader) {
   const struct {
     const char* headers;
     bool expected_result;
     bool expected_has_intermediary;
@@ skipping 109 matching lines @@
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     bool has_chrome_proxy_via_header, has_intermediary;
     if (tests[i].ignore_intermediary) {
       has_chrome_proxy_via_header =
-          HasDataReductionProxyViaHeader(parsed, NULL);
+          HasDataReductionProxyViaHeader(parsed.get(), NULL);
     }
     else {
       has_chrome_proxy_via_header =
-          HasDataReductionProxyViaHeader(parsed, &has_intermediary);
+          HasDataReductionProxyViaHeader(parsed.get(), &has_intermediary);
     }
     EXPECT_EQ(tests[i].expected_result, has_chrome_proxy_via_header);
     if (has_chrome_proxy_via_header && !tests[i].ignore_intermediary) {
       EXPECT_EQ(tests[i].expected_has_intermediary, has_intermediary);
     }
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest, GetDataReductionProxyBypassEventType) {
   const struct {
@@ skipping 95 matching lines @@
       "Via: 1.1 Chrome-Compression-Proxy\n",
       BYPASS_EVENT_TYPE_MAX,
     }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
     DataReductionProxyInfo chrome_proxy_info;
-    EXPECT_EQ(tests[i].expected_result,
-              GetDataReductionProxyBypassType(parsed, &chrome_proxy_info));
+    EXPECT_EQ(
+        tests[i].expected_result,
+        GetDataReductionProxyBypassType(parsed.get(), &chrome_proxy_info));
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest,
        GetDataReductionProxyActionFingerprintChromeProxy) {
   const struct {
      std::string label;
      const char* headers;
      bool expected_fingerprint_exist;
      std::string expected_fingerprint;
@@ skipping 18 matching lines @@
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     std::string fingerprint;
     bool fingerprint_exist = GetDataReductionProxyActionFingerprintChromeProxy(
-        parsed, &fingerprint);
+        parsed.get(), &fingerprint);
     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
         << tests[i].label;
 
     if (fingerprint_exist)
       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest,
        GetDataReductionProxyActionFingerprintVia) {
@@ skipping 23 matching lines @@
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     std::string fingerprint;
     bool fingerprint_exist =
-        GetDataReductionProxyActionFingerprintVia(parsed, &fingerprint);
+        GetDataReductionProxyActionFingerprintVia(parsed.get(), &fingerprint);
     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
         << tests[i].label;
 
     if (fingerprint_exist)
       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest,
        GetDataReductionProxyActionFingerprintOtherHeaders) {
@@ skipping 22 matching lines @@
       "foh1",
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     std::string fingerprint;
-    bool fingerprint_exist =
-        GetDataReductionProxyActionFingerprintOtherHeaders(
-        parsed, &fingerprint);
+    bool fingerprint_exist = GetDataReductionProxyActionFingerprintOtherHeaders(
+        parsed.get(), &fingerprint);
     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
         << tests[i].label;
 
     if (fingerprint_exist)
       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest,
        GetDataReductionProxyActionFingerprintContentLength) {
@@ skipping 23 matching lines @@
     },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string headers(tests[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     std::string fingerprint;
     bool fingerprint_exist =
-        GetDataReductionProxyActionFingerprintContentLength(
-        parsed, &fingerprint);
+        GetDataReductionProxyActionFingerprintContentLength(parsed.get(),
+                                                            &fingerprint);
     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
         << tests[i].label;
 
     if (fingerprint_exist)
       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
   }
 }
 
 TEST_F(DataReductionProxyHeadersTest,
        GetDataReductionProxyHeaderWithFingerprintRemoved) {
@@ skipping 42 matching lines @@
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test); ++i) {
     std::string headers(test[i].headers);
     HeadersToRaw(&headers);
     scoped_refptr<net::HttpResponseHeaders> parsed(
         new net::HttpResponseHeaders(headers));
 
     std::vector<std::string> output_values;
-    GetDataReductionProxyHeaderWithFingerprintRemoved(parsed, &output_values);
+    GetDataReductionProxyHeaderWithFingerprintRemoved(parsed.get(),
+                                                      &output_values);
 
     std::string output_values_string;
     for (size_t j = 0; j < output_values.size(); ++j)
       output_values_string += output_values[j] + ",";
 
     EXPECT_EQ(test[i].expected_output_values_string, output_values_string)
         << test[i].label;
   }
 }
 
 }  // namespace data_reduction_proxy