Remove unneeded scoped_refptr<>::get() on method binding

components/history/core/browser/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 208 matching lines @@
                base::MakeCriticalClosure(base::Bind(
                    &HistoryBackend::PersistState, history_backend_.get())));
 }
 #endif
 
 void HistoryService::ClearCachedDataForContextID(ContextID context_id) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::ClearCachedDataForContextID,
-                          history_backend_.get(), context_id));
+                          history_backend_, context_id));
 }
 
 URLDatabase* HistoryService::InMemoryDatabase() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return in_memory_backend_ ? in_memory_backend_->db() : nullptr;
 }
 
 TypedUrlSyncableService* HistoryService::GetTypedUrlSyncableService() const {
   return history_backend_->GetTypedUrlSyncableService();
 }
 
 void HistoryService::Shutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Cleanup();
 }
 
 void HistoryService::SetKeywordSearchTermsForURL(const GURL& url,
                                                  KeywordID keyword_id,
                                                  const base::string16& term) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::SetKeywordSearchTermsForURL,
-                          history_backend_.get(), url, keyword_id, term));
+                          history_backend_, url, keyword_id, term));
 }
 
 void HistoryService::DeleteAllSearchTermsForKeyword(KeywordID keyword_id) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (in_memory_backend_)
     in_memory_backend_->DeleteAllSearchTermsForKeyword(keyword_id);
 
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::DeleteAllSearchTermsForKeyword,
-                          history_backend_.get(), keyword_id));
+                          history_backend_, keyword_id));
 }
 
 void HistoryService::DeleteKeywordSearchTermForURL(const GURL& url) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::DeleteKeywordSearchTermForURL,
-                          history_backend_.get(), url));
+                          history_backend_, url));
 }
 
 void HistoryService::DeleteMatchingURLsForKeyword(KeywordID keyword_id,
                                                   const base::string16& term) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI,
                base::Bind(&HistoryBackend::DeleteMatchingURLsForKeyword,
-                          history_backend_.get(), keyword_id, term));
+                          history_backend_, keyword_id, term));
 }
 
 void HistoryService::URLsNoLongerBookmarked(const std::set<GURL>& urls) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::URLsNoLongerBookmarked,
-                          history_backend_.get(), urls));
+                          history_backend_, urls));
 }
 
 void HistoryService::AddObserver(HistoryServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
 }
 
 void HistoryService::RemoveObserver(HistoryServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.RemoveObserver(observer);
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::ScheduleDBTask(
     std::unique_ptr<HistoryDBTask> task,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::CancelableTaskTracker::IsCanceledCallback is_canceled;
   base::CancelableTaskTracker::TaskId task_id =
       tracker->NewTrackedTaskId(&is_canceled);
   // Use base::ThreadTaskRunnerHandler::Get() to get a task runner for
   // the current message loop so that we can forward the call to the method
   // HistoryDBTask::DoneRunOnMainThread() in the correct thread.
   thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&HistoryBackend::ProcessDBTask,
-                            history_backend_.get(), base::Passed(&task),
+                            history_backend_, base::Passed(&task),
                             base::ThreadTaskRunnerHandle::Get(), is_canceled));
   return task_id;
 }
 
 void HistoryService::FlushForTest(const base::Closure& flushed) {
   thread_->task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&base::DoNothing), flushed);
 }
 
 void HistoryService::SetOnBackendDestroyTask(const base::Closure& task) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(
       PRIORITY_NORMAL,
       base::Bind(&HistoryBackend::SetOnBackendDestroyTask,
-                 history_backend_.get(), base::MessageLoop::current(), task));
+                 history_backend_, base::MessageLoop::current(), task));
 }
 
 void HistoryService::TopHosts(size_t num_hosts,
                               const TopHostsCallback& callback) const {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::TopHosts, history_backend_.get(), num_hosts),
+      base::Bind(&HistoryBackend::TopHosts, history_backend_, num_hosts),
       callback);
 }
 
 void HistoryService::GetCountsAndLastVisitForOrigins(
     const std::set<GURL>& origins,
     const GetCountsAndLastVisitForOriginsCallback& callback) const {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetCountsAndLastVisitForOrigins,
-                 history_backend_.get(), origins),
+                 history_backend_, origins),
       callback);
 }
 
 void HistoryService::HostRankIfAvailable(
     const GURL& url,
     const base::Callback<void(int)>& callback) const {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(thread_->task_runner().get(), FROM_HERE,
                              base::Bind(&HistoryBackend::HostRankIfAvailable,
-                                        history_backend_.get(), url),
+                                        history_backend_, url),
                              callback);
 }
 
 void HistoryService::AddPage(const GURL& url,
                              Time time,
                              ContextID context_id,
                              int nav_entry_id,
                              const GURL& referrer,
                              const RedirectList& redirects,
                              ui::PageTransition transition,
@@ skipping 32 matching lines @@
       // add_page_args.redirects which mean we can use VisitDelegate::AddURLs()
       // with the whole array.
       DCHECK_EQ(add_page_args.url, add_page_args.redirects.back());
       visit_delegate_->AddURLs(add_page_args.redirects);
     } else {
       visit_delegate_->AddURL(add_page_args.url);
     }
   }
 
   ScheduleTask(PRIORITY_NORMAL,
-               base::Bind(&HistoryBackend::AddPage, history_backend_.get(),
+               base::Bind(&HistoryBackend::AddPage, history_backend_,
                           add_page_args));
 }
 
 void HistoryService::AddPageNoVisitForBookmark(const GURL& url,
                                                const base::string16& title) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_ && !history_client_->CanAddURL(url))
     return;
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::AddPageNoVisitForBookmark,
-                          history_backend_.get(), url, title));
+                          history_backend_, url, title));
 }
 
 void HistoryService::SetPageTitle(const GURL& url,
                                   const base::string16& title) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::SetPageTitle,
-                                           history_backend_.get(), url, title));
+                                           history_backend_, url, title));
 }
 
 void HistoryService::UpdateWithPageEndTime(ContextID context_id,
                                            int nav_entry_id,
                                            const GURL& url,
                                            Time end_ts) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(
       PRIORITY_NORMAL,
-      base::Bind(&HistoryBackend::UpdateWithPageEndTime, history_backend_.get(),
+      base::Bind(&HistoryBackend::UpdateWithPageEndTime, history_backend_,
                  context_id, nav_entry_id, url, end_ts));
 }
 
 void HistoryService::AddPageWithDetails(const GURL& url,
                                         const base::string16& title,
                                         int visit_count,
                                         int typed_count,
                                         Time last_visit,
                                         bool hidden,
                                         VisitSource visit_source) {
@@ skipping 12 matching lines @@
   row.set_visit_count(visit_count);
   row.set_typed_count(typed_count);
   row.set_last_visit(last_visit);
   row.set_hidden(hidden);
 
   URLRows rows;
   rows.push_back(row);
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::AddPagesWithDetails,
-                          history_backend_.get(), rows, visit_source));
+                          history_backend_, rows, visit_source));
 }
 
 void HistoryService::AddPagesWithDetails(const URLRows& info,
                                          VisitSource visit_source) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Inform the VisitDelegate of the URLs
   if (!info.empty() && visit_delegate_) {
     std::vector<GURL> urls;
     urls.reserve(info.size());
     for (const auto& row : info)
       urls.push_back(row.url());
     visit_delegate_->AddURLs(urls);
   }
 
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::AddPagesWithDetails,
-                          history_backend_.get(), info, visit_source));
+                          history_backend_, info, visit_source));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetFavicons(
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetFavicons, history_backend_.get(),
+      base::Bind(&HistoryBackend::GetFavicons, history_backend_,
                  icon_urls, icon_types, desired_sizes, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetFaviconsForURL(
     const GURL& page_url,
     int icon_types,
     const std::vector<int>& desired_sizes,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetFaviconsForURL, history_backend_.get(),
+      base::Bind(&HistoryBackend::GetFaviconsForURL, history_backend_,
                  page_url, icon_types, desired_sizes, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetLargestFaviconForURL(
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   favicon_base::FaviconRawBitmapResult* result =
       new favicon_base::FaviconRawBitmapResult();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetLargestFaviconForURL,
-                 history_backend_.get(), page_url, icon_types,
+                 history_backend_, page_url, icon_types,
                  minimum_size_in_pixels, result),
       base::Bind(&RunWithFaviconResult, callback, base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetFaviconForID(
     favicon_base::FaviconID favicon_id,
     int desired_size,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetFaviconForID, history_backend_.get(),
+      base::Bind(&HistoryBackend::GetFaviconForID, history_backend_,
                  favicon_id, desired_size, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 base::CancelableTaskTracker::TaskId
 HistoryService::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<favicon_base::FaviconRawBitmapResult>* results =
       new std::vector<favicon_base::FaviconRawBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::UpdateFaviconMappingsAndFetch,
-                 history_backend_.get(), page_url, icon_urls, icon_types,
+                 history_backend_, page_url, icon_urls, icon_types,
                  desired_sizes, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 void HistoryService::MergeFavicon(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_ && !history_client_->CanAddURL(page_url))
     return;
 
   ScheduleTask(
       PRIORITY_NORMAL,
-      base::Bind(&HistoryBackend::MergeFavicon, history_backend_.get(),
+      base::Bind(&HistoryBackend::MergeFavicon, history_backend_,
                  page_url, icon_url, icon_type, bitmap_data, pixel_size));
 }
 
 void HistoryService::SetFavicons(const GURL& page_url,
                                  favicon_base::IconType icon_type,
                                  const GURL& icon_url,
                                  const std::vector<SkBitmap>& bitmaps) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_ && !history_client_->CanAddURL(page_url))
     return;
 
   ScheduleTask(PRIORITY_NORMAL,
-               base::Bind(&HistoryBackend::SetFavicons, history_backend_.get(),
+               base::Bind(&HistoryBackend::SetFavicons, history_backend_,
                           page_url, icon_type, icon_url, bitmaps));
 }
 
 void HistoryService::SetFaviconsOutOfDateForPage(const GURL& page_url) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::SetFaviconsOutOfDateForPage,
-                          history_backend_.get(), page_url));
+                          history_backend_, page_url));
 }
 
 void HistoryService::SetImportedFavicons(
     const favicon_base::FaviconUsageDataList& favicon_usage) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL,
                base::Bind(&HistoryBackend::SetImportedFavicons,
-                          history_backend_.get(), favicon_usage));
+                          history_backend_, favicon_usage));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryURL(
     const GURL& url,
     bool want_visits,
     const QueryURLCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   QueryURLResult* query_url_result = new QueryURLResult();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryURL, history_backend_.get(), url,
+      base::Bind(&HistoryBackend::QueryURL, history_backend_, url,
                  want_visits, base::Unretained(query_url_result)),
       base::Bind(&RunWithQueryURLResult, callback,
                  base::Owned(query_url_result)));
 }
 
 // Statistics ------------------------------------------------------------------
 
 base::CancelableTaskTracker::TaskId HistoryService::GetHistoryCount(
     const Time& begin_time,
     const Time& end_time,
     const GetHistoryCountCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return tracker->PostTaskAndReplyWithResult(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetHistoryCount,
-                 history_backend_.get(),
+                 history_backend_,
                  begin_time,
                  end_time),
       callback);
 }
 
 // Downloads -------------------------------------------------------------------
 
 // Handle creation of a download by creating an entry in the history service's
 // 'downloads' table.
 void HistoryService::CreateDownload(
     const DownloadRow& create_info,
     const HistoryService::DownloadCreateCallback& callback) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(thread_->task_runner().get(), FROM_HERE,
                              base::Bind(&HistoryBackend::CreateDownload,
-                                        history_backend_.get(), create_info),
+                                        history_backend_, create_info),
                              callback);
 }
 
 void HistoryService::GetNextDownloadId(const DownloadIdCallback& callback) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   PostTaskAndReplyWithResult(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::GetNextDownloadId, history_backend_.get()),
+      base::Bind(&HistoryBackend::GetNextDownloadId, history_backend_),
       callback);
 }
 
 // Handle queries for a list of all downloads in the history database's
 // 'downloads' table.
 void HistoryService::QueryDownloads(const DownloadQueryCallback& callback) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<DownloadRow>* rows = new std::vector<DownloadRow>();
   std::unique_ptr<std::vector<DownloadRow>> scoped_rows(rows);
   // Beware! The first Bind() does not simply |scoped_rows.get()| because
   // base::Passed(&scoped_rows) nullifies |scoped_rows|, and compilers do not
   // guarantee that the first Bind's arguments are evaluated before the second
   // Bind's arguments.
   thread_->task_runner()->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&HistoryBackend::QueryDownloads, history_backend_.get(), rows),
+      base::Bind(&HistoryBackend::QueryDownloads, history_backend_, rows),
       base::Bind(callback, base::Passed(&scoped_rows)));
 }
 
 // Handle updates for a particular download. This is a 'fire and forget'
 // operation, so we don't need to be called back.
 void HistoryService::UpdateDownload(const DownloadRow& data) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::UpdateDownload,
-                                           history_backend_.get(), data));
+                                           history_backend_, data));
 }
 
 void HistoryService::RemoveDownloads(const std::set<uint32_t>& ids) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::RemoveDownloads,
-                                           history_backend_.get(), ids));
+                                           history_backend_, ids));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryHistory(
     const base::string16& text_query,
     const QueryOptions& options,
     const QueryHistoryCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   QueryResults* query_results = new QueryResults();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryHistory, history_backend_.get(),
+      base::Bind(&HistoryBackend::QueryHistory, history_backend_,
                  text_query, options, base::Unretained(query_results)),
       base::Bind(callback, base::Owned(query_results)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryRedirectsFrom(
     const GURL& from_url,
     const QueryRedirectsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   RedirectList* result = new RedirectList();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryRedirectsFrom, history_backend_.get(),
+      base::Bind(&HistoryBackend::QueryRedirectsFrom, history_backend_,
                  from_url, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryRedirectsTo(
     const GURL& to_url,
     const QueryRedirectsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   RedirectList* result = new RedirectList();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryRedirectsTo, history_backend_.get(),
+      base::Bind(&HistoryBackend::QueryRedirectsTo, history_backend_,
                  to_url, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::GetVisibleVisitCountToHost(
     const GURL& url,
     const GetVisibleVisitCountToHostCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   VisibleVisitCountToHostResult* result = new VisibleVisitCountToHostResult();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&HistoryBackend::GetVisibleVisitCountToHost,
-                 history_backend_.get(), url, base::Unretained(result)),
+                 history_backend_, url, base::Unretained(result)),
       base::Bind(&RunWithVisibleVisitCountToHostResult, callback,
                  base::Owned(result)));
 }
 
 base::CancelableTaskTracker::TaskId HistoryService::QueryMostVisitedURLs(
     int result_count,
     int days_back,
     const QueryMostVisitedURLsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   MostVisitedURLList* result = new MostVisitedURLList();
   return tracker->PostTaskAndReply(
       thread_->task_runner().get(), FROM_HERE,
-      base::Bind(&HistoryBackend::QueryMostVisitedURLs, history_backend_.get(),
+      base::Bind(&HistoryBackend::QueryMostVisitedURLs, history_backend_,
                  result_count, days_back, base::Unretained(result)),
       base::Bind(callback, base::Owned(result)));
 }
 
 void HistoryService::Cleanup() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!thread_) {
     // We've already cleaned up.
     return;
   }
@@ skipping 26 matching lines @@
     //
     // Therefore, we create a closure to run the Closing operation first. This
     // holds a reference to the backend. Then we release our reference, then we
     // schedule the task to run. After the task runs, it will delete its
     // reference from the history thread, ensuring everything works properly.
     //
     // TODO(ajwong): Cleanup HistoryBackend lifetime issues.
     //     See http://crbug.com/99767.
     history_backend_->AddRef();
     base::Closure closing_task =
-        base::Bind(&HistoryBackend::Closing, history_backend_.get());
+        base::Bind(&HistoryBackend::Closing, history_backend_);
     ScheduleTask(PRIORITY_NORMAL, closing_task);
     closing_task.Reset();
     HistoryBackend* raw_ptr = history_backend_.get();
     history_backend_ = nullptr;
     thread_->task_runner()->ReleaseSoon(FROM_HERE, raw_ptr);
   }
 
   // Delete the thread, which joins with the background thread. We defensively
   // nullptr the pointer before deleting it in case somebody tries to use it
   // during shutdown, but this shouldn't happen.
@@ skipping 19 matching lines @@
 
   // Create the history backend.
   scoped_refptr<HistoryBackend> backend(new HistoryBackend(
       new BackendDelegate(weak_ptr_factory_.GetWeakPtr(),
                           base::ThreadTaskRunnerHandle::Get()),
       history_client_ ? history_client_->CreateBackendClient() : nullptr,
       thread_->task_runner()));
   history_backend_.swap(backend);
 
   ScheduleTask(PRIORITY_UI,
-               base::Bind(&HistoryBackend::Init, history_backend_.get(),
+               base::Bind(&HistoryBackend::Init, history_backend_,
                           no_db, history_database_params));
 
   if (visit_delegate_ && !visit_delegate_->Init(this))
     return false;
 
   if (history_client_)
     history_client_->OnHistoryServiceCreated(this);
 
   return true;
 }
 
 void HistoryService::ScheduleAutocomplete(
     const base::Callback<void(HistoryBackend*, URLDatabase*)>& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleTask(PRIORITY_UI, base::Bind(&HistoryBackend::ScheduleAutocomplete,
-                                       history_backend_.get(), callback));
+                                       history_backend_, callback));
 }
 
 void HistoryService::ScheduleTask(SchedulePriority priority,
                                   const base::Closure& task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(thread_);
   CHECK(thread_->message_loop());
   // TODO(brettw): Do prioritization.
   thread_->task_runner()->PostTask(FROM_HERE, task);
 }
@@ skipping 58 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_)
     history_client_->NotifyProfileError(init_status, diagnostics);
 }
 
 void HistoryService::DeleteURL(const GURL& url) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // We will update the visited links when we observe the delete notifications.
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::DeleteURL,
-                                           history_backend_.get(), url));
+                                           history_backend_, url));
 }
 
 void HistoryService::DeleteURLsForTest(const std::vector<GURL>& urls) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   // We will update the visited links when we observe the delete
   // notifications.
   ScheduleTask(PRIORITY_NORMAL, base::Bind(&HistoryBackend::DeleteURLs,
-                                           history_backend_.get(), urls));
+                                           history_backend_, urls));
 }
 
 void HistoryService::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls,
     Time begin_time,
     Time end_time,
     const base::Closure& callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 132 matching lines @@
   return favicon_changed_callback_list_.Add(callback);
 }
 
 void HistoryService::NotifyFaviconsChanged(const std::set<GURL>& page_urls,
                                            const GURL& icon_url) {
   DCHECK(thread_checker_.CalledOnValidThread());
   favicon_changed_callback_list_.Notify(page_urls, icon_url);
 }
 
 }  // namespace history