Remove implicit conversions from scoped_refptr to T* in chrome/browser/extensions/

chrome/browser/extensions/blacklist_state_fetcher.cc

 // Copyright 2013 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/extensions/blacklist_state_fetcher.h"
 
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/safe_browsing/protocol_manager_helper.h"
@@ skipping 22 matching lines @@
         parent_context_getter->GetURLRequestContext());
   }
 
   static void Create(
       scoped_refptr<net::URLRequestContextGetter> parent_context_getter,
       base::Callback<void(scoped_refptr<net::URLRequestContextGetter>)>
           callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     scoped_refptr<net::URLRequestContextGetter> context_getter =
-        new BlacklistRequestContextGetter(parent_context_getter);
+        new BlacklistRequestContextGetter(parent_context_getter.get());
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(callback, context_getter));
   }
 
   virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     return url_request_context_.get();
   }
 
@@ skipping 38 matching lines @@
           FROM_HERE, base::Bind(callback, BLACKLISTED_UNKNOWN));
       return;
     }
   }
 
   bool request_already_sent = ContainsKey(callbacks_, id);
   callbacks_.insert(std::make_pair(id, callback));
   if (request_already_sent)
     return;
 
-  if (url_request_context_getter_ ||
-      !g_browser_process || !g_browser_process->safe_browsing_service()) {
+  if (url_request_context_getter_.get() || !g_browser_process ||
+      !g_browser_process->safe_browsing_service()) {
     SendRequest(id);
   } else {
     scoped_refptr<net::URLRequestContextGetter> parent_request_context;
     if (g_browser_process && g_browser_process->safe_browsing_service()) {
       parent_request_context = g_browser_process->safe_browsing_service()
                                                 ->url_request_context();
     } else {
       parent_request_context = parent_request_context_for_test_;
     }
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&BlacklistRequestContextGetter::Create,
                    parent_request_context,
                    base::Bind(&BlacklistStateFetcher::SaveRequestContext,
                               weak_ptr_factory_.GetWeakPtr(),
                               id)));
   }
 }
 
 void BlacklistStateFetcher::SaveRequestContext(
     const std::string& id,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!url_request_context_getter_)
+  if (!url_request_context_getter_.get())
     url_request_context_getter_ = request_context_getter;
   SendRequest(id);
 }
 
 void BlacklistStateFetcher::SendRequest(const std::string& id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ClientCRXListInfoRequest request;
   request.set_id(id);
   std::string request_str;
   request.SerializeToString(&request_str);
 
   GURL request_url = RequestUrl();
   net::URLFetcher* fetcher = net::URLFetcher::Create(url_fetcher_id_++,
                                                      request_url,
                                                      net::URLFetcher::POST,
                                                      this);
   requests_[fetcher] = id;
   fetcher->SetAutomaticallyRetryOn5xx(false);  // Don't retry on error.
-  fetcher->SetRequestContext(url_request_context_getter_);
+  fetcher->SetRequestContext(url_request_context_getter_.get());
   fetcher->SetUploadData("application/octet-stream", request_str);
   fetcher->Start();
 }
 
 void BlacklistStateFetcher::SetSafeBrowsingConfig(
     const SafeBrowsingProtocolConfig& config) {
   safe_browsing_config_.reset(new SafeBrowsingProtocolConfig(config));
 }
 
 void BlacklistStateFetcher::SetURLRequestContextForTest(
@@ skipping 61 matching lines @@
        callback_it != range.second;
        ++callback_it) {
     callback_it->second.Run(state);
   }
 
   callbacks_.erase(range.first, range.second);
 }
 
 }  // namespace extensions