Call scoped_refptr<T>::get() rather than relying on implicit "operator T*"

chrome/browser/history/history_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.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
@@ skipping 611 matching lines @@
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy(),
+      thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFavicons,
-                 history_backend_.get(), icon_urls, icon_types,
-                 desired_size_in_dip, desired_scale_factors, results),
+                 history_backend_.get(),
+                 icon_urls,
+                 icon_types,
+                 desired_size_in_dip,
+                 desired_scale_factors,
+                 results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 CancelableTaskTracker::TaskId HistoryService::GetFaviconsForURL(
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy(),
+      thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconsForURL,
-                 history_backend_.get(), page_url, icon_types,
-                 desired_size_in_dip, desired_scale_factors, results),
+                 history_backend_.get(),
+                 page_url,
+                 icon_types,
+                 desired_size_in_dip,
+                 desired_scale_factors,
+                 results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 CancelableTaskTracker::TaskId HistoryService::GetFaviconForID(
     chrome::FaviconID favicon_id,
     int desired_size_in_dip,
     ui::ScaleFactor desired_scale_factor,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy(),
+      thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconForID,
-                 history_backend_.get(), favicon_id,
-                 desired_size_in_dip, desired_scale_factor, results),
+                 history_backend_.get(),
+                 favicon_id,
+                 desired_size_in_dip,
+                 desired_scale_factor,
+                 results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 CancelableTaskTracker::TaskId HistoryService::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
-      thread_->message_loop_proxy(),
+      thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::UpdateFaviconMappingsAndFetch,
-                 history_backend_.get(), page_url, icon_urls, icon_types,
-                 desired_size_in_dip, desired_scale_factors, results),
+                 history_backend_.get(),
+                 page_url,
+                 icon_urls,
+                 icon_types,
+                 desired_size_in_dip,
+                 desired_scale_factors,
+                 results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 void HistoryService::MergeFavicon(
     const GURL& page_url,
     const GURL& icon_url,
     chrome::IconType icon_type,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 393 matching lines @@
 
 void HistoryService::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls,
     Time begin_time,
     Time end_time,
     const base::Closure& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(history_backend_.get());
-  tracker->PostTaskAndReply(thread_->message_loop_proxy(),
+  tracker->PostTaskAndReply(thread_->message_loop_proxy().get(),
                             FROM_HERE,
                             base::Bind(&HistoryBackend::ExpireHistoryBetween,
                                        history_backend_,
                                        restrict_urls,
                                        begin_time,
                                        end_time),
                             callback);
 }
 
 void HistoryService::ExpireHistory(
     const std::vector<history::ExpireHistoryArgs>& expire_list,
     const base::Closure& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(history_backend_.get());
   tracker->PostTaskAndReply(
-      thread_->message_loop_proxy(),
+      thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::ExpireHistory, history_backend_, expire_list),
       callback);
 }
 
 void HistoryService::ExpireLocalAndRemoteHistoryBetween(
     const std::set<GURL>& restrict_urls,
     Time begin_time,
     Time end_time,
     const base::Closure& callback,
@@ skipping 131 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   visit_database_observers_.RemoveObserver(observer);
 }
 
 void HistoryService::NotifyVisitDBObserversOnAddVisit(
     const history::BriefVisitInfo& info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(history::VisitDatabaseObserver, visit_database_observers_,
                     OnAddVisit(info));
 }