Mojo C++ bindings: keep connection error handler on the stack while running it.

mojo/public/cpp/bindings/tests/interface_ptr_unittest.cc

 // 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.
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
@@ skipping 777 matching lines @@
         EXPECT_EQ("greetings", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
 
   request.ResetWithReason(88u, "greetings");
 
   run_loop.Run();
 }
 
-TEST_F(InterfacePtrTest, CallbackOwnsInterfacePtr) {
+TEST_F(InterfacePtrTest, CallbackIsPassedInterfacePtr) {
   sample::PingTestPtr ptr;
   sample::PingTestRequest request(&ptr);
 
   base::RunLoop run_loop;
 
   // Make a call with the proxy's lifetime bound to the response callback.
   sample::PingTest* raw_proxy = ptr.get();
   ptr.set_connection_error_handler(run_loop.QuitClosure());
   raw_proxy->Ping(
       base::Bind([](sample::PingTestPtr ptr) {}, base::Passed(&ptr)));
 
   // Trigger an error on |ptr|. This will ultimately lead to the proxy's
   // response callbacks being destroyed, which will in turn lead to the proxy
   // being destroyed. This should not crash.
   request.PassMessagePipe();
   run_loop.Run();
 }
 
+TEST_F(InterfacePtrTest, ConnectionErrorHandlerOwnsInterfacePtr) {
+  sample::PingTestPtr* ptr = new sample::PingTestPtr;
+  sample::PingTestRequest request(ptr);
+
+  base::RunLoop run_loop;
+
+  // Make a call with |ptr|'s lifetime bound to the connection error handler
+  // callback.
+  ptr->set_connection_error_handler(base::Bind(
+      [](const base::Closure& quit, sample::PingTestPtr* ptr) {
+        ptr->reset();
+        quit.Run();
+      },
+      run_loop.QuitClosure(), base::Owned(ptr)));
+
+  // Trigger an error on |ptr|. In the error handler |ptr| is reset. This
+  // shouldn't immediately destroy the callback (and |ptr| that it owns), before
+  // the callback is completed.
+  request.PassMessagePipe();
+  run_loop.Run();
+}
+
 TEST_F(InterfacePtrTest, ThreadSafeInterfacePointer) {
   math::CalculatorPtr ptr;
   MathCalculatorImpl calc_impl(MakeRequest(&ptr));
   scoped_refptr<math::ThreadSafeCalculatorPtr> thread_safe_ptr =
       math::ThreadSafeCalculatorPtr::Create(std::move(ptr));
 
   base::RunLoop run_loop;
 
   // Create and start the thread from where we'll call the interface pointer.
   base::Thread other_thread("service test thread");
@@ skipping 79 matching lines @@
   other_thread_task_runner->DeleteSoon(FROM_HERE, math_calc_impl);
 
   // Reset the pointer now so the InterfacePtr associated resources can be
   // deleted before the background thread's message loop is invalidated.
   thread_safe_ptr = nullptr;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo