Update //docs/callback.md for OnceCallback support of PostTask impls

docs/callback.md

 # Callback<> and Bind()
 
 ## Introduction
 
 The templated `Callback<>` class is a generalized function object. Together with
 the `Bind()` function in base/bind.h, they provide a type-safe method for
 performing partial application of functions.
 
 Partial application (or "currying") is the process of binding a subset of a
 function's arguments to produce another function that takes fewer arguments.
@@ skipping 49 matching lines @@
   g_cb = std::move(cb);
 }
 
 // |Baz| takes the ownership of |cb| and consumes |cb| by Run().
 void Baz(OnceCallback<void(int)> cb) {
   std::move(cb).Run(42);
 }
 
 // |Qux| takes the ownership of |cb| and transfers ownership to PostTask(),
 // which also takes the ownership of |cb|.
-// NOTE: TaskRunner is not actually migrated to OnceClosure yet. Once TaskRunner
-// supports OnceClosure, a OnceCallback can be posted as follows:
 void Qux(OnceCallback<void(int)> cb) {
   PostTask(FROM_HERE,
-           base::BindOnce(std::move(cb), 42));  // not yet implemented!
+           base::BindOnce(std::move(cb), 42));
 }
 ```
 
 When you pass a `Callback` object to a function parameter, use `std::move()` if
 you don't need to keep a reference to it, otherwise, pass the object directly.
 You may see a compile error when the function requires the exclusive ownership,
 and you didn't pass the callback by move.
 
 ## Quick reference for basic stuff
 
@@ skipping 373 matching lines @@
    Example:
 ```cpp
 void Foo(const char* ptr);
 void Bar(char* ptr);
 Bind(&Foo, "test");
 Bind(&Bar, "test");  // This fails because ptr is not const.
 ```
 
 If you are thinking of forward declaring `Callback` in your own header file,
 please include "base/callback_forward.h" instead.