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

components/invalidation/impl/non_blocking_invalidator.cc

 // Copyright 2014 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 "components/invalidation/impl/non_blocking_invalidator.h"
 
 #include <cstddef>
 #include <memory>
 #include <utility>
 
@@ skipping 231 matching lines @@
 
   InitializeOptions initialize_options(
       network_channel_creator, invalidator_client_id, saved_invalidations,
       invalidation_bootstrap_data, weak_ptr_this,
       base::ThreadTaskRunnerHandle::Get(), client_info, request_context_getter);
 
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &NonBlockingInvalidator::Core::Initialize,
-              core_.get(),
+              core_,
               initialize_options))) {
     NOTREACHED();
   }
 }
 
 NonBlockingInvalidator::~NonBlockingInvalidator() {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&NonBlockingInvalidator::Core::Teardown,
-                     core_.get()))) {
+                     core_))) {
     DVLOG(1) << "Network thread stopped before invalidator is destroyed.";
   }
 }
 
 void NonBlockingInvalidator::RegisterHandler(InvalidationHandler* handler) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.RegisterHandler(handler);
 }
 
 bool NonBlockingInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
                                                  const ObjectIdSet& ids) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!registrar_.UpdateRegisteredIds(handler, ids))
     return false;
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &NonBlockingInvalidator::Core::UpdateRegisteredIds,
-              core_.get(),
+              core_,
               registrar_.GetAllRegisteredIds()))) {
     NOTREACHED();
   }
   return true;
 }
 
 void NonBlockingInvalidator::UnregisterHandler(InvalidationHandler* handler) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.UnregisterHandler(handler);
 }
 
 InvalidatorState NonBlockingInvalidator::GetInvalidatorState() const {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   return registrar_.GetInvalidatorState();
 }
 
 void NonBlockingInvalidator::UpdateCredentials(const std::string& email,
                                                const std::string& token) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&NonBlockingInvalidator::Core::UpdateCredentials,
-                     core_.get(), email, token))) {
+                     core_, email, token))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidator::RequestDetailedStatus(
     base::Callback<void(const base::DictionaryValue&)> callback) const {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   base::Callback<void(const base::DictionaryValue&)> proxy_callback =
       base::Bind(&CallbackProxy::Run, base::Owned(new CallbackProxy(callback)));
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&NonBlockingInvalidator::Core::RequestDetailedStatus,
-                     core_.get(),
+                     core_,
                      proxy_callback))) {
     NOTREACHED();
   }
 }
 
 NetworkChannelCreator
     NonBlockingInvalidator::MakePushClientChannelCreator(
         const notifier::NotifierOptions& notifier_options) {
   return base::Bind(SyncNetworkChannel::CreatePushClientChannel,
       notifier_options);
@@ skipping 50 matching lines @@
 
 void NonBlockingInvalidator::OnIncomingInvalidation(
         const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 
 std::string NonBlockingInvalidator::GetOwnerName() const { return "Sync"; }
 
 }  // namespace syncer