Update documentation for base::ResetAndReturn(Callback*)

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 134 matching lines @@
 RepeatingCallbacks can be run more than once (they don't get deleted or marked
 when run). However, this precludes using Passed (see below).
 
 ```cpp
 void DoSomething(const RepeatingCallback<double(double)>& callback) {
   double myresult = callback.Run(3.14159);
   myresult += callback.Run(2.71828);
 }
 ```
 
+If running a callback could result in its own destruction (e.g., if the callback
+recipient deletes the object the callback is a member of), the callback should
+be moved before it can be safely invoked. The `base::ResetAndReturn` method
+provides this functionality.
+
+```cpp
+Foo::RunCallback() {

[tzik, 2017/03/17 14:01:06]

nit: void Foo::RunCallback() {

[michaelpg, 2017/03/17 22:58:20]

whoops, done

+  base::ResetAndReturn(&foo_deleter_callback_).Run();
+}
+```
+
 ### Passing Unbound Input Parameters
 
 Unbound parameters are specified at the time a callback is `Run()`. They are
 specified in the `Callback` template type:
 
 ```cpp
 void MyFunc(int i, const std::string& str) {}
 Callback<void(int, const std::string&)> cb = Bind(&MyFunc);
 cb.Run(23, "hello, world");
 ```
@@ skipping 282 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.