Add assert() for scoped_refptr<T>::operator->()

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 <cassert>
+
 #include "base/atomic_ref_count.h"
 #include "base/base_export.h"
 #include "base/threading/thread_collision_warner.h"
 
 namespace base {
 
 namespace subtle {
 
 class BASE_EXPORT RefCountedBase {
  public:
@@ skipping 217 matching lines @@
       ptr_->AddRef();
   }
 
   ~scoped_refptr() {
     if (ptr_)
       ptr_->Release();
   }
 
   T* get() const { return ptr_; }
   operator T*() const { return ptr_; }
-  T* operator->() const { return ptr_; }
+  T* operator->() const {
+    assert(ptr_ != NULL);

[jar (doing other things), 2012/01/28 02:47:22]

Could you clarify when this would be significant?

I'd assume that the result of this operator would be immediately deref'ed, to
get to some slot. I'd then expect it to segv.  Hence, the assert would be a
debug-only warning that the code is about to crash.

What caller-usage pattern am I missing?

+    return 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 34 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_