Correct threading documentation example.

docs/design/threading.md

 # Threading
 
 [TOC]
 
 ## Overview
 
 Chromium is a very multithreaded product. We try to keep the UI as responsive as
 possible, and this means not blocking the UI thread with any blocking I/O or
 other expensive operations. Our approach is to use message passing as the way of
 communicating between threads. We discourage locking and threadsafe
 objects. Instead, objects live on only one thread, we pass messages between
 threads for communication, and we use callback interfaces (implemented by
 message passing) for most cross-thread requests.
 
 The `Thread` object is defined in
 [`base/threading/thread.h`](https://cs.chromium.org/chromium/src/base/threading/thread.h).
 In general you should probably use one of the existing threads described below
 rather than make new ones. We already have a lot of threads that are difficult
 to keep track of. Each thread has a `MessageLoop` (see
 [`base/message_loop/message_loop.h`](https://cs.chromium.org/chromium/src/base/message_loop/message_loop.h)
 that processes messages for that thread. You can get the message loop for a
-thread using the `Thread.message_loop()` function.  More details about 
+thread using the `Thread.message_loop()` function.  More details about
 `MessageLoop` can be found in
 [Anatomy of Chromium MessageLoop](https://docs.google.com/document/d/1_pJUHO3f3VyRSQjEhKVvUU7NzCyuTCQshZvbWeQiCXU/view#).
 
 ## Existing threads
 
 Most threads are managed by the BrowserProcess object, which acts as the service
 manager for the main "browser" process. By default, everything happens on the UI
 thread. We have pushed certain classes of processing into these other
 threads. It has getters for the following threads:
 
@@ skipping 202 matching lines @@
 raw pointer with `make_scoped_refptr()`:
 
     class SomeParamObject : public base::RefCountedThreadSafe<SomeParamObject> {
      ...
     };
 
     class MyObject : public base::RefCountedThreadSafe<MyObject> {
      public:
       void DoSomething() {
         scoped_refptr<SomeParamObject> param(new SomeParamObject);
-        thread_->message_loop()->PostTask(FROM_HERE
-           base::Bind(&MyObject::DoSomethingOnAnotherThread, this, param));
+
+        // Without RetainedRef, the scoped_refptr would try to implicitly
+        // convert to a raw pointer and fail compilation.
+        thread_->message_loop()->PostTask(FROM_HERE,
+           base::Bind(&MyObject::DoSomethingOnAnotherThread, this,
+           base::RetainedRef(param)));
       }
+
       void DoSomething2() {
         SomeParamObject* param = new SomeParamObject;
-        thread_->message_loop()->PostTask(FROM_HERE
+        thread_->message_loop()->PostTask(FROM_HERE,
            base::Bind(&MyObject::DoSomethingOnAnotherThread, this,
-                             make_scoped_refptr(param)));
+                             base::RetainedRef(make_scoped_refptr(param))));
       }
+
+      void DoSomething3() {
+        scoped_refptr<SomeParamObject> param(new SomeParamObject);
+
+        // Moving |param| prevents an extra AddRef()/Release() pair.
+        thread_->message_loop()->PostTask(FROM_HERE,
+           base::Bind(&MyObject::DoSomethingOnAnotherThread, this,
+           base::RetainedRef(std::move(param))));
+      }
+
       // Note how this takes a raw pointer. The important part is that
       // base::Bind() was passed a scoped_refptr; using a scoped_refptr
       // here would result in an extra AddRef()/Release() pair.
       void DoSomethingOnAnotherThread(SomeParamObject* param) {
         ...
       }
     };
 
 If you want to pass the object without taking a reference on it, wrap the
 argument with `base::Unretained()`. Again, using this means there are external
@@ skipping 223 matching lines @@
           int some_input1, int some_input2) {
         if (request->canceled())
           return;
 
         ... do your processing ...
 
         // Execute ForwardResult() like you would do Run() on the base::Callback<>.
         request->ForwardResult(return_value);
       }
     };