Remove implicit conversions from scoped_refptr to T* in mojo/

mojo/system/handle_table.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 "mojo/system/handle_table.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/dispatcher.h"
@@ skipping 19 matching lines @@
   // This should usually not be reached (the only instance should be owned by
   // the singleton |Core|, which lives forever), except in tests.
 }
 
 Dispatcher* HandleTable::GetDispatcher(MojoHandle handle) {
   DCHECK_NE(handle, MOJO_HANDLE_INVALID);
 
   HandleToEntryMap::iterator it = handle_to_entry_map_.find(handle);
   if (it == handle_to_entry_map_.end())
     return NULL;
-  return it->second.dispatcher;
+  return it->second.dispatcher.get();
 }
 
 MojoResult HandleTable::GetAndRemoveDispatcher(
     MojoHandle handle,
     scoped_refptr<Dispatcher>* dispatcher) {
   DCHECK_NE(handle, MOJO_HANDLE_INVALID);
   DCHECK(dispatcher);
 
   HandleToEntryMap::iterator it = handle_to_entry_map_.find(handle);
   if (it == handle_to_entry_map_.end())
@@ skipping 31 matching lines @@
   COMPILE_ASSERT(
       static_cast<uint64_t>(kMaxHandleTableSize) + kMaxMessageNumHandles <
           (sizeof(size_t) == 8 ? kuint64max
                                : static_cast<uint64_t>(kuint32max)),
       addition_may_overflow);
 
   if (handle_to_entry_map_.size() + dispatchers.size() > kMaxHandleTableSize)
     return false;
 
   for (size_t i = 0; i < dispatchers.size(); i++) {
-    if (dispatchers[i]) {
+    if (dispatchers[i].get()) {
       handles[i] = AddDispatcherNoSizeCheck(dispatchers[i]);
     } else {
       LOG(WARNING) << "Invalid dispatcher at index " << i;
       handles[i] = MOJO_HANDLE_INVALID;
     }
   }
   return true;
 }
 
 MojoResult HandleTable::MarkBusyAndStartTransport(
@@ skipping 76 matching lines @@
       (*transports)[j].End();
     }
     return error_result;
   }
 
   return MOJO_RESULT_OK;
 }
 
 MojoHandle HandleTable::AddDispatcherNoSizeCheck(
     const scoped_refptr<Dispatcher>& dispatcher) {
-  DCHECK(dispatcher);
+  DCHECK(dispatcher.get());
   DCHECK_LT(handle_to_entry_map_.size(), kMaxHandleTableSize);
   DCHECK_NE(next_handle_, MOJO_HANDLE_INVALID);
 
   // TODO(vtl): Maybe we want to do something different/smarter. (Or maybe try
   // assigning randomly?)
   while (handle_to_entry_map_.find(next_handle_) !=
          handle_to_entry_map_.end()) {
     next_handle_++;
     if (next_handle_ == MOJO_HANDLE_INVALID)
       next_handle_++;
@@ skipping 31 matching lines @@
   for (uint32_t i = 0; i < num_handles; i++) {
     HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]);
     DCHECK(it != handle_to_entry_map_.end());
     DCHECK(it->second.busy);
     it->second.busy = false;
   }
 }
 
 }  // namespace system
 }  // namespace mojo