Remove implicit conversions from scoped_refptr to T* in net/

net/base/sdch_manager_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 <limits.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 179 matching lines @@
   // enabled.
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_FALSE(dictionary_list.empty());
 
   // Dictionary should be available.
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
-  EXPECT_TRUE(dictionary != NULL);
+  EXPECT_TRUE(dictionary.get() != NULL);
 }
 
 TEST_F(SdchManagerTest, CanNotUseHTTPDictionaryOverHTTPS) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
               GURL("http://" + dictionary_domain)));
 
   GURL target_url("https://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTPS target URL should not advertise dictionary acquired over HTTP even if
   // secure scheme support is enabled.
   SdchManager::EnableSecureSchemeSupport(true);
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
-  EXPECT_TRUE(dictionary == NULL);
+  EXPECT_TRUE(dictionary.get() == NULL);
 }
 
 TEST_F(SdchManagerTest, CanNotUseHTTPSDictionaryOverHTTP) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   SdchManager::EnableSecureSchemeSupport(true);
   EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
               GURL("https://" + dictionary_domain)));
 
   GURL target_url("http://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTP target URL should not advertise dictionary acquired over HTTPS even if
   // secure scheme support is enabled.
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
-  EXPECT_TRUE(dictionary == NULL);
+  EXPECT_TRUE(dictionary.get() == NULL);
 }
 
 TEST_F(SdchManagerTest, FailToSetDomainMismatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the "domain match" requirement.
   EXPECT_FALSE(sdch_manager()->AddSdchDictionary(dictionary_text,
                GURL("http://y.z.google.com")));
 }
@@ skipping 165 matching lines @@
 
   // Confirm that if you add directories to one manager, you
   // can't get them from the other.
   EXPECT_TRUE(sdch_manager()->AddSdchDictionary(
       dictionary_text_1, GURL("http://" + dictionary_domain_1)));
   scoped_refptr<SdchManager::Dictionary> dictionary;
   sdch_manager()->GetVcdiffDictionary(
       server_hash_1,
       GURL("http://" + dictionary_domain_1 + "/random_url"),
       &dictionary);
-  EXPECT_TRUE(dictionary);
+  EXPECT_TRUE(dictionary.get());
 
   EXPECT_TRUE(second_manager.AddSdchDictionary(
       dictionary_text_2, GURL("http://" + dictionary_domain_2)));
   second_manager.GetVcdiffDictionary(
       server_hash_2,
       GURL("http://" + dictionary_domain_2 + "/random_url"),
       &dictionary);
-  EXPECT_TRUE(dictionary);
+  EXPECT_TRUE(dictionary.get());
 
   sdch_manager()->GetVcdiffDictionary(
       server_hash_2,
       GURL("http://" + dictionary_domain_2 + "/random_url"),
       &dictionary);
-  EXPECT_FALSE(dictionary);
+  EXPECT_FALSE(dictionary.get());
 
   second_manager.GetVcdiffDictionary(
       server_hash_1,
       GURL("http://" + dictionary_domain_1 + "/random_url"),
       &dictionary);
-  EXPECT_FALSE(dictionary);
+  EXPECT_FALSE(dictionary.get());
 }
 
 TEST_F(SdchManagerTest, HttpsCorrectlySupported) {
   GURL url("http://www.google.com");
   GURL secure_url("https://www.google.com");
 
   EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(url));
   EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(secure_url));
 
   SdchManager::EnableSecureSchemeSupport(true);
@@ skipping 11 matching lines @@
 
   SdchManager::GenerateHash(dictionary_text, &tmp_hash, &server_hash);
 
   EXPECT_TRUE(sdch_manager()->AddSdchDictionary(
       dictionary_text, GURL("http://" + dictionary_domain)));
   scoped_refptr<SdchManager::Dictionary> dictionary;
   sdch_manager()->GetVcdiffDictionary(
       server_hash,
       GURL("http://" + dictionary_domain + "/random_url"),
       &dictionary);
-  EXPECT_TRUE(dictionary);
+  EXPECT_TRUE(dictionary.get());
 
   sdch_manager()->BlacklistDomain(GURL(blacklist_url),
                                   SdchManager::MIN_PROBLEM_CODE);
   EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(blacklist_url));
 
   sdch_manager()->ClearData();
 
   dictionary = NULL;
   sdch_manager()->GetVcdiffDictionary(
       server_hash,
       GURL("http://" + dictionary_domain + "/random_url"),
       &dictionary);
-  EXPECT_FALSE(dictionary);
+  EXPECT_FALSE(dictionary.get());
   EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(blacklist_url));
 }
 
 }  // namespace net