Mojo C++ bindings: refactor SyncHandleWatcher.

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

 // Copyright 2016 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 "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
@@ skipping 348 matching lines @@
   base::RunLoop run_loop1;
   impl.set_async_echo_handler(
       [&async_echo_request_value, &async_echo_request_callback, &run_loop1](
           int32_t value, const TestSync::AsyncEchoCallback& callback) {
         async_echo_request_value = value;
         async_echo_request_callback = callback;
         run_loop1.Quit();
       });
 
   bool async_echo_response_dispatched = false;
+  bool connection_error_dispatched = false;
   base::RunLoop run_loop2;
-  ptr->AsyncEcho(123,
-                 [&async_echo_response_dispatched, &run_loop2](int32_t result) {
-                   async_echo_response_dispatched = true;
-                   EXPECT_EQ(123, result);
-                   run_loop2.Quit();
-                 });
+  ptr->AsyncEcho(
+      123, [&async_echo_response_dispatched, &connection_error_dispatched, &ptr,
+            &run_loop2](int32_t result) {
+        async_echo_response_dispatched = true;
+        // At this point, error notification should not be dispatched
+        // yet.
+        EXPECT_FALSE(connection_error_dispatched);
+        EXPECT_FALSE(ptr.encountered_error());
+        EXPECT_EQ(123, result);
+        run_loop2.Quit();
+      });
   // Run until the AsyncEcho request reaches the service side.
   run_loop1.Run();
 
   impl.set_echo_handler(
       [&impl, &async_echo_request_value, &async_echo_request_callback](
           int32_t value, const TestSync::EchoCallback& callback) {
         // Send back the async response first.
         EXPECT_FALSE(async_echo_request_callback.is_null());
         async_echo_request_callback.Run(async_echo_request_value);
 
         impl.binding()->Close();
       });
 
-  bool connection_error_dispatched = false;
   base::RunLoop run_loop3;
   ptr.set_connection_error_handler(
       [&connection_error_dispatched, &run_loop3]() {
         connection_error_dispatched = true;
         run_loop3.Quit();
       });
 
   int32_t result_value = -1;
   ASSERT_FALSE(ptr->Echo(456, &result_value));
   EXPECT_EQ(-1, result_value);
   ASSERT_FALSE(connection_error_dispatched);
   EXPECT_FALSE(ptr.encountered_error());
 
   // Although the AsyncEcho response arrives before the Echo response, it should
   // be queued and not yet dispatched.
   EXPECT_FALSE(async_echo_response_dispatched);
 
   // Run until the AsyncEcho response is dispatched.
   run_loop2.Run();
 
   EXPECT_TRUE(async_echo_response_dispatched);
-  ASSERT_FALSE(connection_error_dispatched);
-  EXPECT_FALSE(ptr.encountered_error());
 
   // Run until the error notification is dispatched.
   run_loop3.Run();
 
   ASSERT_TRUE(connection_error_dispatched);
   EXPECT_TRUE(ptr.encountered_error());
 }
 
 TEST_F(SyncMethodTest, InvalidMessageDuringSyncCall) {
   // Test that while an interface pointer is waiting for the response to a sync
@@ skipping 32 matching lines @@
   EXPECT_EQ(-1, result_value);
   ASSERT_FALSE(connection_error_dispatched);
 
   run_loop.Run();
   ASSERT_TRUE(connection_error_dispatched);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo