Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/safe_browsing/download_protection_service.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 "chrome/browser/safe_browsing/download_protection_service.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 219 matching lines @@
       const DownloadProtectionService::CheckDownloadCallback& callback,
       const scoped_refptr<SafeBrowsingUIManager>& ui_manager,
       const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager)
       : DownloadSBClient(item, callback, ui_manager,
                          DOWNLOAD_URL_CHECKS_TOTAL,
                          DOWNLOAD_URL_CHECKS_MALWARE),
         database_manager_(database_manager) { }
 
   virtual void StartCheck() OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    if (!database_manager_ || database_manager_->CheckDownloadUrl(
-           url_chain_, this)) {
+    if (!database_manager_.get() ||
+        database_manager_->CheckDownloadUrl(url_chain_, this)) {
       CheckDone(SB_THREAT_TYPE_SAFE);
     } else {
       AddRef();  // SafeBrowsingService takes a pointer not a scoped_refptr.
     }
   }
 
   virtual bool IsDangerous(SBThreatType threat_type) const OVERRIDE {
     return threat_type == SB_THREAT_TYPE_BINARY_MALWARE_URL;
   }
 
@@ skipping 292 matching lines @@
     if (!zipped_executable_) {
       PostFinishTask(SAFE, REASON_ARCHIVE_WITHOUT_BINARIES);
       return;
     }
     OnFileFeatureExtractionDone();
   }
 
   void CheckWhitelists() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     DownloadCheckResultReason reason = REASON_MAX;
-    if (!database_manager_) {
+    if (!database_manager_.get()) {
       reason = REASON_SB_DISABLED;
     } else {
       for (size_t i = 0; i < url_chain_.size(); ++i) {
         const GURL& url = url_chain_[i];
         if (url.is_valid() &&
             database_manager_->MatchDownloadWhitelistUrl(url)) {
           VLOG(2) << url << " is on the download whitelist.";
           reason = REASON_WHITELISTED_URL;
           break;
         }
@@ skipping 147 matching lines @@
     for (int i = 1; i < chain.element_size(); ++i) {
       scoped_refptr<net::X509Certificate> issuer =
           net::X509Certificate::CreateFromBytes(
               chain.element(i).certificate().data(),
               chain.element(i).certificate().size());
       if (!issuer.get()) {
         return false;
       }
       std::vector<std::string> whitelist_strings;
       DownloadProtectionService::GetCertificateWhitelistStrings(
-          *cert, *issuer, &whitelist_strings);
+          *cert.get(), *issuer.get(), &whitelist_strings);
       for (size_t j = 0; j < whitelist_strings.size(); ++j) {
         if (database_manager_->MatchDownloadWhitelistString(
                 whitelist_strings[j])) {
           VLOG(2) << "Certificate matched whitelist, cert="
                   << cert->subject().GetDisplayName()
                   << " issuer=" << issuer->subject().GetDisplayName();
           return true;
         }
       }
       cert = issuer;
@@ skipping 213 matching lines @@
   std::string url = kDownloadRequestUrl;
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty()) {
     base::StringAppendF(&url, "?key=%s",
                         net::EscapeQueryParamValue(api_key, true).c_str());
   }
   return url;
 }
 
 }  // namespace safe_browsing