Remove implicit scoped_refptr operator T*

chrome/browser/net/predictor.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/net/predictor.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <sstream>
@@ skipping 226 matching lines @@
         // connections, and actually cost the server more than if we did a real
         // get with a fake request (/gen_204 might be the good path on Google).
         const int kMaxSearchKeepaliveSeconds(10);
         if ((now - last_omnibox_preconnect_).InSeconds() <
              kMaxSearchKeepaliveSeconds)
           return;  // We've done a preconnect recently.
         last_omnibox_preconnect_ = now;
         const int kConnectionsNeeded = 1;
         PreconnectOnUIThread(CanonicalizeUrl(url), motivation,
                              kConnectionsNeeded,
-                             url_request_context_getter_);
+                             url_request_context_getter_.get());
         return;  // Skip pre-resolution, since we'll open a connection.
       }
     } else {
       consecutive_omnibox_preconnect_count_ = 0;
     }
   }
 
   // Fall through and consider pre-resolution.
 
   // Omnibox tends to call in pairs (just a few milliseconds apart), and we
@@ skipping 19 matching lines @@
   if (!predictor_enabled_)
     return;
   if (!url.is_valid() || !url.has_host())
     return;
   if (preconnect_enabled()) {
     std::string host = url.HostNoBrackets();
     UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
     const int kConnectionsNeeded = 1;
     PreconnectOnUIThread(CanonicalizeUrl(url), motivation,
                          kConnectionsNeeded,
-                         url_request_context_getter_);
+                         url_request_context_getter_.get());
     PredictFrameSubresources(url.GetWithEmptyPath());
   }
 }
 
 UrlList Predictor::GetPredictedUrlListAtStartup(
     PrefService* user_prefs,
     PrefService* local_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UrlList urls;
   // Recall list of URLs we learned about during last session.
@@ skipping 556 matching lines @@
   Referrers::iterator it = referrers_.find(url);
   if (referrers_.end() == it) {
     // Only when we don't know anything about this url, make 2 connections
     // available.  We could do this completely via learning (by prepopulating
     // the referrer_ list with this expected value), but it would swell the
     // size of the list with all the "Leaf" nodes in the tree (nodes that don't
     // load any subresources).  If we learn about this resource, we will instead
     // provide a more carefully estimated preconnection count.
     if (preconnect_enabled_) {
       PreconnectOnIOThread(url, UrlInfo::SELF_REFERAL_MOTIVATED, 2,
-                           url_request_context_getter_);
+                           url_request_context_getter_.get());
     }
     return;
   }
 
   Referrer* referrer = &(it->second);
   referrer->IncrementUseCount();
   const UrlInfo::ResolutionMotivation motivation =
       UrlInfo::LEARNED_REFERAL_MOTIVATED;
   for (Referrer::iterator future_url = referrer->begin();
        future_url != referrer->end(); ++future_url) {
     SubresourceValue evalution(TOO_NEW);
     double connection_expectation = future_url->second.subresource_use_rate();
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.PreconnectSubresourceExpectation",
                                 static_cast<int>(connection_expectation * 100),
                                 10, 5000, 50);
     future_url->second.ReferrerWasObserved();
     if (preconnect_enabled_ &&
         connection_expectation > kPreconnectWorthyExpectedValue) {
       evalution = PRECONNECTION;
       future_url->second.IncrementPreconnectionCount();
       int count = static_cast<int>(std::ceil(connection_expectation));
       if (url.host() == future_url->first.host())
         ++count;
       PreconnectOnIOThread(future_url->first, motivation, count,
-                           url_request_context_getter_);
+                           url_request_context_getter_.get());
     } else if (connection_expectation > kDNSPreresolutionWorthyExpectedValue) {
       evalution = PRERESOLUTION;
       future_url->second.preresolution_increment();
       UrlInfo* queued_info = AppendToResolutionQueue(future_url->first,
                                                      motivation);
       if (queued_info)
         queued_info->SetReferringHostname(url);
     }
     UMA_HISTOGRAM_ENUMERATION("Net.PreconnectSubresourceEval", evalution,
                               SUBRESOURCE_VALUE_MAX);
@@ skipping 285 matching lines @@
     IOThread* io_thread,
     net::URLRequestContextGetter* getter) {
   // Empty function for unittests.
 }
 
 void SimplePredictor::ShutdownOnUIThread(PrefService* user_prefs) {
   SetShutdown(true);
 }
 
 }  // namespace chrome_browser_net