Update sync/, sql/, and printing/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

sync/internal_api/http_bridge.cc

 // Copyright 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 "sync/internal_api/public/http_bridge.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "net/base/load_flags.h"
@@ skipping 11 matching lines @@
 
 namespace syncer {
 
 HttpBridge::RequestContextGetter::RequestContextGetter(
     net::URLRequestContextGetter* baseline_context_getter,
     const std::string& user_agent)
     : baseline_context_getter_(baseline_context_getter),
       network_task_runner_(
           baseline_context_getter_->GetNetworkTaskRunner()),
       user_agent_(user_agent) {
-  DCHECK(baseline_context_getter_);
-  DCHECK(network_task_runner_);
+  DCHECK(baseline_context_getter_.get());
+  DCHECK(network_task_runner_.get());
   DCHECK(!user_agent_.empty());
 }
 
 HttpBridge::RequestContextGetter::~RequestContextGetter() {}
 
 net::URLRequestContext*
 HttpBridge::RequestContextGetter::GetURLRequestContext() {
   // Lazily create the context.
   if (!context_) {
     net::URLRequestContext* baseline_context =
@@ skipping 19 matching lines @@
     : request_context_getter_(
         new HttpBridge::RequestContextGetter(
             baseline_context_getter, user_agent)),
       network_time_update_callback_(network_time_update_callback) {
 }
 
 HttpBridgeFactory::~HttpBridgeFactory() {
 }
 
 HttpPostProviderInterface* HttpBridgeFactory::Create() {
-  HttpBridge* http = new HttpBridge(request_context_getter_,
+  HttpBridge* http = new HttpBridge(request_context_getter_.get(),
                                     network_time_update_callback_);
   http->AddRef();
   return http;
 }
 
 void HttpBridgeFactory::Destroy(HttpPostProviderInterface* http) {
   static_cast<HttpBridge*>(http)->Release();
 }
 
 HttpBridge::RequestContext::RequestContext(
@@ skipping 137 matching lines @@
 
 void HttpBridge::MakeAsynchronousPost() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   base::AutoLock lock(fetch_state_lock_);
   DCHECK(!fetch_state_.request_completed);
   if (fetch_state_.aborted)
     return;
 
   fetch_state_.url_poster = net::URLFetcher::Create(
       url_for_request_, net::URLFetcher::POST, this);
-  fetch_state_.url_poster->SetRequestContext(context_getter_for_request_);
+  fetch_state_.url_poster->SetRequestContext(context_getter_for_request_.get());
   fetch_state_.url_poster->SetUploadData(content_type_, request_content_);
   fetch_state_.url_poster->SetExtraRequestHeaders(extra_headers_);
   fetch_state_.url_poster->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES);
   fetch_state_.start_time = base::Time::Now();
   fetch_state_.url_poster->Start();
 }
 
 int HttpBridge::GetResponseContentLength() const {
   DCHECK_EQ(base::MessageLoop::current(), created_on_loop_);
   base::AutoLock lock(fetch_state_lock_);
@@ skipping 74 matching lines @@
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetch_state_.url_poster);
   fetch_state_.url_poster = NULL;
 
   // Wake the blocked syncer thread in MakeSynchronousPost.
   // WARNING: DONT DO ANYTHING AFTER THIS CALL! |this| may be deleted!
   http_post_completed_.Signal();
 }
 
 net::URLRequestContextGetter* HttpBridge::GetRequestContextGetterForTest()
     const {
-  return context_getter_for_request_;
+  return context_getter_for_request_.get();
 }
 
 void HttpBridge::UpdateNetworkTime() {
   std::string sane_time_str;
   if (!fetch_state_.request_succeeded || fetch_state_.start_time.is_null() ||
       fetch_state_.end_time < fetch_state_.start_time ||
       !fetch_state_.response_headers->EnumerateHeader(NULL, "Sane-Time-Millis",
                                                       &sane_time_str)) {
     return;
   }
 
   int64 sane_time_ms = 0;
   if (base::StringToInt64(sane_time_str, &sane_time_ms)) {
     network_time_update_callback_.Run(
         base::Time::FromJsTime(sane_time_ms),
         base::TimeDelta::FromMilliseconds(1),
         fetch_state_.end_time - fetch_state_.start_time);
   }
 }
 
 }  // namespace syncer