Eliminate implicit conversion from scoped_refptr<T> to T*

base/memory/ref_counted.h

 // 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.
 
 #ifndef BASE_MEMORY_REF_COUNTED_H_
 #define BASE_MEMORY_REF_COUNTED_H_
 #pragma once
 
 #include "base/atomic_ref_count.h"
 #include "base/base_export.h"
@@ skipping 224 matching lines @@
     if (ptr_)
       ptr_->AddRef();
   }
 
   ~scoped_refptr() {
     if (ptr_)
       ptr_->Release();
   }
 
   T* get() const { return ptr_; }
-  operator T*() const { return ptr_; }
   T* operator->() const { return ptr_; }
 
+  // This operator allows a scoped_refptr to be safely evaluated as bool, using
+  // the "Safe bool" idiom. By "safely", we mean that we are opening up as few
+  // unsafe operations as possible. Simply using operator bool() can allow
+  // silliness like:
+  //   int x = my_scoped_refptr;
+  //   return (my_scoped_refptr < 5);
+  // See, e.g., http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Safe_bool
+  // for more information on this idiom.
+  typedef void (scoped_refptr<T>::*BoolType)() const;
+  void this_type_does_not_support_comparisons() const {}
+  operator BoolType() const {
+    return ptr_ ? &scoped_refptr<T>::this_type_does_not_support_comparisons :
+                  NULL;
+  }
+
+  // Allow scoped_refptr<T> to be used in tree-based containers. Note that
+  // operator< on pointers is technically implementation-defined, but it works
+  // on all our platforms and is a common idiom in Chromium anyway.
+  bool operator<(const scoped_refptr<T>& right) const {
+    return ptr_ < right.ptr_;
+  }
+
   // Release a pointer.
   // The return value is the current pointer held by this object.
   // If this object holds a NULL pointer, the return value is NULL.
   // After this operation, this object will hold a NULL pointer,
   // and will not own the object any more.
   T* release() {
     T* retVal = ptr_;
     ptr_ = NULL;
     return retVal;
   }
@@ skipping 33 matching lines @@
 };
 
 // Handy utility for creating a scoped_refptr<T> out of a T* explicitly without
 // having to retype all the template arguments
 template <typename T>
 scoped_refptr<T> make_scoped_refptr(T* t) {
   return scoped_refptr<T>(t);
 }
 
 #endif  // BASE_MEMORY_REF_COUNTED_H_