Plug some of the leaks in dbus_unittests.

dbus/property_unittest.cc

 // Copyright (c) 2012 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 "dbus/property.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/bus.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/test_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace dbus {
 
@@ skipping 74 matching lines @@
     // Stopping a thread is considered an IO operation, so do this after
     // allowing IO.
     test_service_->Stop();
   }
 
   // Generic callback, bind with a string |id| for passing to
   // WaitForCallback() to ensure the callback for the right method is
   // waited for.
   void PropertyCallback(const std::string& id, bool success) {
     last_callback_ = id;
-    message_loop_.Quit();
+    run_loop_->Quit();
   }
 
  protected:
   // Called when a property value is updated.
   void OnPropertyChanged(const std::string& name) {
     updated_properties_.push_back(name);
-    message_loop_.Quit();
+    run_loop_->Quit();
   }
 
   // Waits for the given number of updates.
   void WaitForUpdates(size_t num_updates) {
-    while (updated_properties_.size() < num_updates)
-      message_loop_.Run();
+    while (updated_properties_.size() < num_updates) {
+      run_loop_.reset(new base::RunLoop);
+      run_loop_->Run();
+    }
     for (size_t i = 0; i < num_updates; ++i)
       updated_properties_.erase(updated_properties_.begin());
   }
 
   // Name, Version, Methods, Objects
   static const int kExpectedSignalUpdates = 5;
 
   // Waits for initial values to be set.
   void WaitForGetAll() {
     WaitForUpdates(kExpectedSignalUpdates);
   }
 
   // Waits for the callback. |id| is the string bound to the callback when
   // the method call is made that identifies it and distinguishes from any
   // other; you can set this to whatever you wish.
   void WaitForCallback(const std::string& id) {
     while (last_callback_ != id) {
-      message_loop_.Run();
+      run_loop_.reset(new base::RunLoop);
+      run_loop_->Run();
     }
   }
 
   base::MessageLoop message_loop_;
+  scoped_ptr<base::RunLoop> run_loop_;
   scoped_ptr<base::Thread> dbus_thread_;
   scoped_refptr<Bus> bus_;
   ObjectProxy* object_proxy_;
   scoped_ptr<Properties> properties_;
   scoped_ptr<TestService> test_service_;
   // Properties updated.
   std::vector<std::string> updated_properties_;
   // Last callback received.
   std::string last_callback_;
 };
@@ skipping 112 matching lines @@
                                    "Set"));
   WaitForCallback("Set");
 
   // TestService sends a property update.
   WaitForUpdates(1);
 
   EXPECT_EQ("NewService", properties_->name.value());
 }
 
 }  // namespace dbus