Remove implicit conversions from scoped_refptr to T* in c/b/chromeos/settings

chrome/browser/chromeos/settings/session_manager_operation.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/chromeos/settings/session_manager_operation.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 56 matching lines @@
   EnsurePublicKey(base::Bind(&SessionManagerOperation::RetrieveDeviceSettings,
                              weak_factory_.GetWeakPtr()));
 }
 
 void SessionManagerOperation::ReportResult(
     DeviceSettingsService::Status status) {
   callback_.Run(this, status);
 }
 
 void SessionManagerOperation::EnsurePublicKey(const base::Closure& callback) {
-  if (force_key_load_ || !public_key_ || !public_key_->is_loaded()) {
+  if (force_key_load_ || !public_key_.get() || !public_key_->is_loaded()) {
     scoped_refptr<base::TaskRunner> task_runner =
         content::BrowserThread::GetBlockingPool()
             ->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
     base::PostTaskAndReplyWithResult(
         task_runner.get(),
         FROM_HERE,
         base::Bind(&SessionManagerOperation::LoadPublicKey,
                    owner_key_util_,
                    public_key_),
         base::Bind(&SessionManagerOperation::StorePublicKey,
                    weak_factory_.GetWeakPtr(),
                    callback));
   } else {
     callback.Run();
   }
 }
 
 // static
 scoped_refptr<PublicKey> SessionManagerOperation::LoadPublicKey(
     scoped_refptr<OwnerKeyUtil> util,
     scoped_refptr<PublicKey> current_key) {
   scoped_refptr<PublicKey> public_key(new PublicKey());
 
   // Keep already-existing public key.
-  if (current_key && current_key->is_loaded()) {
+  if (current_key.get() && current_key->is_loaded()) {
     public_key->data() = current_key->data();
   }
   if (!public_key->is_loaded() && util->IsPublicKeyPresent()) {
     if (!util->ImportPublicKey(&public_key->data()))
       LOG(ERROR) << "Failed to load public owner key.";
   }
 
   return public_key;
 }
 
 void SessionManagerOperation::StorePublicKey(const base::Closure& callback,
                                              scoped_refptr<PublicKey> new_key) {
   force_key_load_ = false;
   public_key_ = new_key;
 
-  if (!public_key_ || !public_key_->is_loaded()) {
+  if (!public_key_.get() || !public_key_->is_loaded()) {
     ReportResult(DeviceSettingsService::STORE_KEY_UNAVAILABLE);
     return;
   }
 
   callback.Run();
 }
 
 void SessionManagerOperation::RetrieveDeviceSettings() {
   session_manager_client()->RetrieveDevicePolicy(
       base::Bind(&SessionManagerOperation::ValidateDeviceSettings,
@@ skipping 160 matching lines @@
 }
 
 void SignAndStoreSettingsOperation::HandleStoreResult(bool success) {
   if (!success)
     ReportResult(DeviceSettingsService::STORE_OPERATION_FAILED);
   else
     StartLoading();
 }
 
 }  // namespace chromeos