Make nesting/running states a RunLoop rather than a MessageLoop concept.

device/bluetooth/bluez/bluetooth_socket_bluez_unittest.cc

Index: device/bluetooth/bluez/bluetooth_socket_bluez_unittest.cc
diff --git a/device/bluetooth/bluez/bluetooth_socket_bluez_unittest.cc b/device/bluetooth/bluez/bluetooth_socket_bluez_unittest.cc
index 74ac10a4d109227e63f78a75ecc05fd92d5f3942..fe73ed38b8e07a2897de79c57b09ca2e0d2d7db7 100644
--- a/device/bluetooth/bluez/bluetooth_socket_bluez_unittest.cc
+++ b/device/bluetooth/bluez/bluetooth_socket_bluez_unittest.cc
@@ -81,10 +81,13 @@ class BluetoothSocketBlueZTest : public testing::Test {
     BluetoothSocketThread::Get();
 
     // Grab a pointer to the adapter.
-    device::BluetoothAdapterFactory::GetAdapter(base::Bind(
-        &BluetoothSocketBlueZTest::AdapterCallback, base::Unretained(this)));
-
-    base::RunLoop().Run();
+    {
+      base::RunLoop run_loop;
+      device::BluetoothAdapterFactory::GetAdapter(
+          base::Bind(&BluetoothSocketBlueZTest::AdapterCallback,
+                     base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+      run_loop.Run();
+    }
 
     ASSERT_TRUE(adapter_.get() != nullptr);
     ASSERT_TRUE(adapter_->IsInitialized());
@@ -102,74 +105,69 @@ class BluetoothSocketBlueZTest : public testing::Test {
     bluez::BluezDBusManager::Shutdown();
   }
 
-  void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) {
+  void AdapterCallback(base::OnceClosure continuation,
+                       scoped_refptr<BluetoothAdapter> adapter) {
     adapter_ = adapter;
-    if (base::MessageLoop::current() &&
-        base::MessageLoop::current()->is_running()) {
-      base::MessageLoop::current()->QuitWhenIdle();
-    }
+    std::move(continuation).Run();
   }
 
-  void SuccessCallback() {
+  void SuccessCallback(base::OnceClosure continuation) {
     ++success_callback_count_;
-    message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
-  void ErrorCallback(const std::string& message) {
+  void ErrorCallback(base::OnceClosure continuation,
+                     const std::string& message) {
     ++error_callback_count_;
     last_message_ = message;
-
-    if (message_loop_.is_running())
-      message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
-  void ConnectToServiceSuccessCallback(scoped_refptr<BluetoothSocket> socket) {
+  void ConnectToServiceSuccessCallback(base::OnceClosure continuation,
+                                       scoped_refptr<BluetoothSocket> socket) {
     ++success_callback_count_;
     last_socket_ = socket;
-
-    message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
-  void SendSuccessCallback(int bytes_sent) {
+  void SendSuccessCallback(base::OnceClosure continuation, int bytes_sent) {
     ++success_callback_count_;
     last_bytes_sent_ = bytes_sent;
-
-    message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
-  void ReceiveSuccessCallback(int bytes_received,
+  void ReceiveSuccessCallback(base::OnceClosure continuation,
+                              int bytes_received,
                               scoped_refptr<net::IOBuffer> io_buffer) {
     ++success_callback_count_;
     last_bytes_received_ = bytes_received;
     last_io_buffer_ = io_buffer;
-
-    message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
-  void ReceiveErrorCallback(BluetoothSocket::ErrorReason reason,
+  void ReceiveErrorCallback(base::OnceClosure continuation,
+                            BluetoothSocket::ErrorReason reason,
                             const std::string& error_message) {
     ++error_callback_count_;
     last_reason_ = reason;
     last_message_ = error_message;
-
-    message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
-  void CreateServiceSuccessCallback(scoped_refptr<BluetoothSocket> socket) {
+  void CreateServiceSuccessCallback(base::OnceClosure continuation,
+                                    scoped_refptr<BluetoothSocket> socket) {
     ++success_callback_count_;
     last_socket_ = socket;
-
-    if (message_loop_.is_running())
-      message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
-  void AcceptSuccessCallback(const BluetoothDevice* device,
+  void AcceptSuccessCallback(base::OnceClosure continuation,
+                             const BluetoothDevice* device,
                              scoped_refptr<BluetoothSocket> socket) {
     ++success_callback_count_;
     last_device_ = device;
     last_socket_ = socket;
-
-    message_loop_.QuitWhenIdle();
+    std::move(continuation).Run();
   }
 
   void ImmediateSuccessCallback() { ++success_callback_count_; }
@@ -197,13 +195,16 @@ TEST_F(BluetoothSocketBlueZTest, Connect) {
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
 
-  device->ConnectToService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      base::Bind(&BluetoothSocketBlueZTest::ConnectToServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    device->ConnectToService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        base::Bind(&BluetoothSocketBlueZTest::ConnectToServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -219,12 +220,16 @@ TEST_F(BluetoothSocketBlueZTest, Connect) {
   scoped_refptr<net::StringIOBuffer> write_buffer(
       new net::StringIOBuffer("test"));
 
-  socket->Send(write_buffer.get(), write_buffer->size(),
-               base::Bind(&BluetoothSocketBlueZTest::SendSuccessCallback,
-                          base::Unretained(this)),
-               base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                          base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    socket->Send(
+        write_buffer.get(), write_buffer->size(),
+        base::Bind(&BluetoothSocketBlueZTest::SendSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -235,12 +240,16 @@ TEST_F(BluetoothSocketBlueZTest, Connect) {
 
   // Receive data from the socket, and fetch the buffer from the callback; since
   // the fake is an echo server, we expect to receive what we wrote.
-  socket->Receive(4096,
-                  base::Bind(&BluetoothSocketBlueZTest::ReceiveSuccessCallback,
-                             base::Unretained(this)),
-                  base::Bind(&BluetoothSocketBlueZTest::ReceiveErrorCallback,
-                             base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    socket->Receive(
+        4096,
+        base::Bind(&BluetoothSocketBlueZTest::ReceiveSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ReceiveErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -260,12 +269,16 @@ TEST_F(BluetoothSocketBlueZTest, Connect) {
 
   // Receive data again; the socket will have been closed, this should cause a
   // disconnected error to be returned via the error callback.
-  socket->Receive(4096,
-                  base::Bind(&BluetoothSocketBlueZTest::ReceiveSuccessCallback,
-                             base::Unretained(this)),
-                  base::Bind(&BluetoothSocketBlueZTest::ReceiveErrorCallback,
-                             base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    socket->Receive(
+        4096,
+        base::Bind(&BluetoothSocketBlueZTest::ReceiveSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ReceiveErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(0U, success_callback_count_);
   EXPECT_EQ(1U, error_callback_count_);
@@ -279,12 +292,16 @@ TEST_F(BluetoothSocketBlueZTest, Connect) {
   // equivalent to the connection reset error.
   write_buffer = new net::StringIOBuffer("second test");
 
-  socket->Send(write_buffer.get(), write_buffer->size(),
-               base::Bind(&BluetoothSocketBlueZTest::SendSuccessCallback,
-                          base::Unretained(this)),
-               base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                          base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    socket->Send(
+        write_buffer.get(), write_buffer->size(),
+        base::Bind(&BluetoothSocketBlueZTest::SendSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(0U, success_callback_count_);
   EXPECT_EQ(1U, error_callback_count_);
@@ -294,23 +311,28 @@ TEST_F(BluetoothSocketBlueZTest, Connect) {
   error_callback_count_ = 0;
 
   // Close our end of the socket.
-  socket->Disconnect(base::Bind(&BluetoothSocketBlueZTest::SuccessCallback,
-                                base::Unretained(this)));
-
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    socket->Disconnect(base::Bind(&BluetoothSocketBlueZTest::SuccessCallback,
+                                  base::Unretained(this),
+                                  run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
   EXPECT_EQ(1U, success_callback_count_);
 }
 
 TEST_F(BluetoothSocketBlueZTest, Listen) {
-  adapter_->CreateRfcommService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      BluetoothAdapter::ServiceOptions(),
-      base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    adapter_->CreateRfcommService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        BluetoothAdapter::ServiceOptions(),
+        base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -334,20 +356,24 @@ TEST_F(BluetoothSocketBlueZTest, Listen) {
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
-  fake_bluetooth_device_client->ConnectProfile(
-      static_cast<BluetoothDeviceBlueZ*>(device)->object_path(),
-      bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
-      base::Bind(&base::DoNothing), base::Bind(&DoNothingDBusErrorCallback));
-
-  base::RunLoop().RunUntilIdle();
-
-  server_socket->Accept(
-      base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
+  {
+    base::RunLoop run_loop;
+    fake_bluetooth_device_client->ConnectProfile(
+        static_cast<BluetoothDeviceBlueZ*>(device)->object_path(),
+        bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
+        base::Bind(&base::DoNothing), base::Bind(&DoNothingDBusErrorCallback));
+    run_loop.RunUntilIdle();
+  }
 
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    server_socket->Accept(
+        base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -360,10 +386,13 @@ TEST_F(BluetoothSocketBlueZTest, Listen) {
   error_callback_count_ = 0;
 
   // Close our end of the client socket.
-  client_socket->Disconnect(base::Bind(
-      &BluetoothSocketBlueZTest::SuccessCallback, base::Unretained(this)));
-
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    client_socket->Disconnect(
+        base::Bind(&BluetoothSocketBlueZTest::SuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   client_socket = nullptr;
@@ -372,20 +401,24 @@ TEST_F(BluetoothSocketBlueZTest, Listen) {
 
   // Run a second connection test, this time calling Accept() before the
   // incoming connection comes in.
-  server_socket->Accept(
-      base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-
-  base::RunLoop().RunUntilIdle();
-
-  fake_bluetooth_device_client->ConnectProfile(
-      static_cast<BluetoothDeviceBlueZ*>(device)->object_path(),
-      bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
-      base::Bind(&base::DoNothing), base::Bind(&DoNothingDBusErrorCallback));
+  {
+    base::RunLoop run_loop;
+    server_socket->Accept(
+        base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.RunUntilIdle();
+  }
 
-  base::RunLoop().Run();

[gab, 2017/05/04 22:12:12]

@scheib: I don't understand how this possibly worked before since the above
call's callback are "DoNothings" and can't possibly quit this loop... and the
RunLoop starts with only that task per the preceding
base::RunLoop().RunUntilIdle(); ...

Anyways... with the new code doing a matching run_loop.Run() on 420 in the RHS
of this diff hangs as I'd expect.

Perhaps some other quit was somehow filtering to this before but now
RunUntilIdle() is clearly the right thing IMO.

[gab, 2017/05/05 02:21:54]

Ah ah, figured it out, with this PS the expectations on 423-425 were failing.
The issue isn't that the loop isn't quit, the issue is that it's quit through
the closure passed in the server_socket->Accept() call above -- as such that
call and the ConnectProfile() call here need to share the same RunLoop!

+  {
+    base::RunLoop run_loop;
+    fake_bluetooth_device_client->ConnectProfile(
+        static_cast<BluetoothDeviceBlueZ*>(device)->object_path(),
+        bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
+        base::Bind(&base::DoNothing), base::Bind(&DoNothingDBusErrorCallback));
+    run_loop.RunUntilIdle();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -398,10 +431,13 @@ TEST_F(BluetoothSocketBlueZTest, Listen) {
   error_callback_count_ = 0;
 
   // Close our end of the client socket.
-  client_socket->Disconnect(base::Bind(
-      &BluetoothSocketBlueZTest::SuccessCallback, base::Unretained(this)));
-
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    client_socket->Disconnect(
+        base::Bind(&BluetoothSocketBlueZTest::SuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   client_socket = nullptr;
@@ -409,11 +445,13 @@ TEST_F(BluetoothSocketBlueZTest, Listen) {
   error_callback_count_ = 0;
 
   // Now close the server socket.
-  server_socket->Disconnect(
-      base::Bind(&BluetoothSocketBlueZTest::ImmediateSuccessCallback,
-                 base::Unretained(this)));
-
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    server_socket->Disconnect(
+        base::Bind(&BluetoothSocketBlueZTest::ImmediateSuccessCallback,
+                   base::Unretained(this)));
+    run_loop.RunUntilIdle();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
 }
@@ -426,14 +464,17 @@ TEST_F(BluetoothSocketBlueZTest, ListenBeforeAdapterStart) {
           bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient());
   fake_bluetooth_adapter_client->SetVisible(false);
 
-  adapter_->CreateRfcommService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      BluetoothAdapter::ServiceOptions(),
-      base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    adapter_->CreateRfcommService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        BluetoothAdapter::ServiceOptions(),
+        base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -457,9 +498,11 @@ TEST_F(BluetoothSocketBlueZTest, ListenBeforeAdapterStart) {
   EXPECT_TRUE(profile_service_provider == nullptr);
 
   // Make the adapter visible. This should register a profile.
-  fake_bluetooth_adapter_client->SetVisible(true);
-
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    fake_bluetooth_adapter_client->SetVisible(true);
+    run_loop.RunUntilIdle();
+  }
 
   profile_service_provider =
       fake_bluetooth_profile_manager_client->GetProfileServiceProvider(
@@ -467,11 +510,13 @@ TEST_F(BluetoothSocketBlueZTest, ListenBeforeAdapterStart) {
   EXPECT_TRUE(profile_service_provider != nullptr);
 
   // Cleanup the socket.
-  socket->Disconnect(
-      base::Bind(&BluetoothSocketBlueZTest::ImmediateSuccessCallback,
-                 base::Unretained(this)));
-
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    socket->Disconnect(
+        base::Bind(&BluetoothSocketBlueZTest::ImmediateSuccessCallback,
+                   base::Unretained(this)));
+    run_loop.RunUntilIdle();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
 }
@@ -482,14 +527,17 @@ TEST_F(BluetoothSocketBlueZTest, ListenAcrossAdapterRestart) {
       static_cast<bluez::FakeBluetoothAdapterClient*>(
           bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient());
 
-  adapter_->CreateRfcommService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      BluetoothAdapter::ServiceOptions(),
-      base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    adapter_->CreateRfcommService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        BluetoothAdapter::ServiceOptions(),
+        base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -514,14 +562,18 @@ TEST_F(BluetoothSocketBlueZTest, ListenAcrossAdapterRestart) {
 
   // Make the adapter invisible, and fiddle with the profile fake to unregister
   // the profile since this doesn't happen automatically.
-  fake_bluetooth_adapter_client->SetVisible(false);
-
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    fake_bluetooth_adapter_client->SetVisible(false);
+    run_loop.RunUntilIdle();
+  }
 
   // Then make the adapter visible again. This should re-register the profile.
-  fake_bluetooth_adapter_client->SetVisible(true);
-
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    fake_bluetooth_adapter_client->SetVisible(true);
+    run_loop.RunUntilIdle();
+  }
 
   profile_service_provider =
       fake_bluetooth_profile_manager_client->GetProfileServiceProvider(
@@ -529,11 +581,13 @@ TEST_F(BluetoothSocketBlueZTest, ListenAcrossAdapterRestart) {
   EXPECT_TRUE(profile_service_provider != nullptr);
 
   // Cleanup the socket.
-  socket->Disconnect(
-      base::Bind(&BluetoothSocketBlueZTest::ImmediateSuccessCallback,
-                 base::Unretained(this)));
-
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    socket->Disconnect(
+        base::Bind(&BluetoothSocketBlueZTest::ImmediateSuccessCallback,
+                   base::Unretained(this)));
+    run_loop.RunUntilIdle();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
 }
@@ -543,25 +597,31 @@ TEST_F(BluetoothSocketBlueZTest, PairedConnectFails) {
       bluez::FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress);
   ASSERT_TRUE(device != nullptr);
 
-  device->ConnectToService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      base::Bind(&BluetoothSocketBlueZTest::ConnectToServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    device->ConnectToService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        base::Bind(&BluetoothSocketBlueZTest::ConnectToServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(0U, success_callback_count_);
   EXPECT_EQ(1U, error_callback_count_);
   EXPECT_TRUE(last_socket_.get() == nullptr);
 
-  device->ConnectToService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      base::Bind(&BluetoothSocketBlueZTest::ConnectToServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    device->ConnectToService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        base::Bind(&BluetoothSocketBlueZTest::ConnectToServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(0U, success_callback_count_);
   EXPECT_EQ(2U, error_callback_count_);
@@ -569,15 +629,17 @@ TEST_F(BluetoothSocketBlueZTest, PairedConnectFails) {
 }
 
 TEST_F(BluetoothSocketBlueZTest, SocketListenTwice) {
-  adapter_->CreateRfcommService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      BluetoothAdapter::ServiceOptions(),
-      base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    adapter_->CreateRfcommService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        BluetoothAdapter::ServiceOptions(),
+        base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(0U, error_callback_count_);
@@ -587,30 +649,34 @@ TEST_F(BluetoothSocketBlueZTest, SocketListenTwice) {
   scoped_refptr<BluetoothSocket> server_socket;
   server_socket.swap(last_socket_);
 
-  server_socket->Accept(
-      base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-
-  server_socket->Close();
+  {
+    base::RunLoop run_loop;
+    server_socket->Accept(
+        base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
 
-  server_socket = nullptr;
+    server_socket->Close();
 
-  base::RunLoop().RunUntilIdle();
+    server_socket = nullptr;
+    run_loop.RunUntilIdle();
+  }
 
   EXPECT_EQ(1U, success_callback_count_);
   EXPECT_EQ(1U, error_callback_count_);
 
-  adapter_->CreateRfcommService(
-      BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
-      BluetoothAdapter::ServiceOptions(),
-      base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-
-  base::RunLoop().Run();
+  {
+    base::RunLoop run_loop;
+    adapter_->CreateRfcommService(
+        BluetoothUUID(bluez::FakeBluetoothProfileManagerClient::kRfcommUuid),
+        BluetoothAdapter::ServiceOptions(),
+        base::Bind(&BluetoothSocketBlueZTest::CreateServiceSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
+    run_loop.Run();
+  }
 
   EXPECT_EQ(2U, success_callback_count_);
   EXPECT_EQ(1U, error_callback_count_);
@@ -619,17 +685,19 @@ TEST_F(BluetoothSocketBlueZTest, SocketListenTwice) {
   // Take control of this socket.
   server_socket.swap(last_socket_);
 
-  server_socket->Accept(
-      base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
-                 base::Unretained(this)));
-
-  server_socket->Close();
+  {
+    base::RunLoop run_loop;
+    server_socket->Accept(
+        base::Bind(&BluetoothSocketBlueZTest::AcceptSuccessCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()),
+        base::Bind(&BluetoothSocketBlueZTest::ErrorCallback,
+                   base::Unretained(this), run_loop.QuitWhenIdleClosure()));
 
-  server_socket = nullptr;
+    server_socket->Close();
 
-  base::RunLoop().RunUntilIdle();
+    server_socket = nullptr;
+    run_loop.RunUntilIdle();
+  }
 
   EXPECT_EQ(2U, success_callback_count_);
   EXPECT_EQ(2U, error_callback_count_);