Fixed example in MessageLoop::ReleaseSoon comment

base/message_loop/message_loop.h

 // Copyright 2013 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_MESSAGE_LOOP_MESSAGE_LOOP_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_
 
 #include <queue>
 #include <string>
 
@@ skipping 190 matching lines @@
     base::subtle::DeleteHelperInternal<T, void>::DeleteViaSequencedTaskRunner(
         this, from_here, object);
   }
 
   // A variant on PostTask that releases the given reference counted object
   // (by calling its Release method).  This is useful if the object needs to
   // live until the next run of the MessageLoop, or if the object needs to be
   // released on a particular thread.
   //
   // A common pattern is to manually increment the object's reference count
   // (AddRef), issue a ReleaseSoon, then clear the pointer.  The reference count

[maniscalco, 2014/05/29 16:40:36]

We should also switch the order of ReleaseSoon and clear in the text so it
matches the corrected example.

[vkuzkokov, 2014/05/30 07:19:32]

Done.

   // is incremented manually to ensure clearing the pointer does not trigger a
   // delete and to account for the upcoming decrement (ReleaseSoon).  For
   // example:
   //
   // scoped_refptr<Foo> foo = ...
-  // foo.AddRef();
-  // message_loop->ReleaseSoon(foo.get());
+  // foo->AddRef();
+  // Foo* raw_foo = foo.get();
   // foo = NULL;

[Mark Mentovai, 2014/05/29 20:42:10]

If everything is RefCountedThreadSafe, why should it matter whether this happens
before or after the call to ReleaseSoon?

[maniscalco, 2014/05/29 22:50:31]

Here's my understanding.  vkuzkokov, correct me if I'm wrong.

In the example code I committed, foo was not cleared until *after* ReleaseSoon()
was called.  Under the covers, ReleaseSoon() will post a task to message_loop. 
If the message_loop thread is "really fast", it could finish executing the
Release() *before* ReleaseSoon() has even returned.  If this happens, foo will
be the last reference and clearing it will destroy the object.

Destroying the Foo here would be bad because the reason for using ReleaseSoon()
in the first place was to ensure it gets destroyed in some other thread (in this
case, message_loop).

+  // message_loop->ReleaseSoon(raw_foo);
   //
   // NOTE: This method may be called on any thread.  The object will be
   // released (and thus possibly deleted) on the thread that executes
   // MessageLoop::Run().  If this is not the same as the thread that calls
   // PostDelayedTask(FROM_HERE, ), then T MUST inherit from
   // RefCountedThreadSafe<T>!
   template <class T>
   void ReleaseSoon(const tracked_objects::Location& from_here,
                    const T* object) {
     base::subtle::ReleaseHelperInternal<T, void>::ReleaseViaSequencedTaskRunner(
@@ skipping 411 matching lines @@
 
 // Do not add any member variables to MessageLoopForIO!  This is important b/c
 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO).  Any extra
 // data that you need should be stored on the MessageLoop's pump_ instance.
 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO),
                MessageLoopForIO_should_not_have_extra_member_variables);
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_