1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/bind.h" 6 #include "base/memory/scoped_ptr.h" 7 #include "base/message_loop/message_loop.h" 8 #include "base/metrics/histogram.h" 9 #include "base/metrics/histogram_samples.h" 10 #include "base/metrics/statistics_recorder.h" 11 #include "base/run_loop.h" 12 #include "base/test/test_timeouts.h" 13 #include "base/threading/platform_thread.h" 14 #include "base/threading/thread_restrictions.h" 15 #include "dbus/bus.h" 16 #include "dbus/message.h" 17 #include "dbus/object_proxy.h" 18 #include "dbus/test_service.h" 19 #include "testing/gtest/include/gtest/gtest.h" 20 21 namespace dbus { 22 23 // The test for sender verification in ObjectProxy. 24 class SignalSenderVerificationTest : public testing::Test { 25 public: 26 SignalSenderVerificationTest() 27 : on_name_owner_changed_called_(false), 28 on_ownership_called_(false) { 29 } 30 31 virtual void SetUp() { 32 base::StatisticsRecorder::Initialize(); 33 34 // Make the main thread not to allow IO. 35 base::ThreadRestrictions::SetIOAllowed(false); 36 37 // Start the D-Bus thread. 38 dbus_thread_.reset(new base::Thread("D-Bus Thread")); 39 base::Thread::Options thread_options; 40 thread_options.message_loop_type = base::MessageLoop::TYPE_IO; 41 ASSERT_TRUE(dbus_thread_->StartWithOptions(thread_options)); 42 43 // Create the client, using the D-Bus thread. 44 Bus::Options bus_options; 45 bus_options.bus_type = Bus::SESSION; 46 bus_options.connection_type = Bus::PRIVATE; 47 bus_options.dbus_task_runner = dbus_thread_->message_loop_proxy(); 48 bus_ = new Bus(bus_options); 49 object_proxy_ = bus_->GetObjectProxy( 50 "org.chromium.TestService", 51 ObjectPath("/org/chromium/TestObject")); 52 ASSERT_TRUE(bus_->HasDBusThread()); 53 54 object_proxy_->SetNameOwnerChangedCallback( 55 base::Bind(&SignalSenderVerificationTest::OnNameOwnerChanged, 56 base::Unretained(this), 57 &on_name_owner_changed_called_)); 58 59 // Connect to the "Test" signal of "org.chromium.TestInterface" from 60 // the remote object. 61 object_proxy_->ConnectToSignal( 62 "org.chromium.TestInterface", 63 "Test", 64 base::Bind(&SignalSenderVerificationTest::OnTestSignal, 65 base::Unretained(this)), 66 base::Bind(&SignalSenderVerificationTest::OnConnected, 67 base::Unretained(this))); 68 // Wait until the object proxy is connected to the signal. 69 run_loop_.reset(new base::RunLoop); 70 run_loop_->Run(); 71 72 // Start the test service, using the D-Bus thread. 73 TestService::Options options; 74 options.dbus_task_runner = dbus_thread_->message_loop_proxy(); 75 test_service_.reset(new TestService(options)); 76 ASSERT_TRUE(test_service_->StartService()); 77 ASSERT_TRUE(test_service_->WaitUntilServiceIsStarted()); 78 ASSERT_TRUE(test_service_->HasDBusThread()); 79 ASSERT_TRUE(test_service_->has_ownership()); 80 81 // Same setup for the second TestService. This service should not have the 82 // ownership of the name at this point. 83 test_service2_.reset(new TestService(options)); 84 ASSERT_TRUE(test_service2_->StartService()); 85 ASSERT_TRUE(test_service2_->WaitUntilServiceIsStarted()); 86 ASSERT_TRUE(test_service2_->HasDBusThread()); 87 ASSERT_FALSE(test_service2_->has_ownership()); 88 89 // The name should be owned and known at this point. 90 if (!on_name_owner_changed_called_) { 91 run_loop_.reset(new base::RunLoop); 92 run_loop_->Run(); 93 } 94 ASSERT_FALSE(latest_name_owner_.empty()); 95 } 96 97 virtual void TearDown() { 98 bus_->ShutdownOnDBusThreadAndBlock(); 99 100 // Shut down the service. 101 test_service_->ShutdownAndBlock(); 102 test_service2_->ShutdownAndBlock(); 103 104 // Reset to the default. 105 base::ThreadRestrictions::SetIOAllowed(true); 106 107 // Stopping a thread is considered an IO operation, so do this after 108 // allowing IO. 109 test_service_->Stop(); 110 test_service2_->Stop(); 111 } 112 113 void OnOwnership(bool expected, bool success) { 114 ASSERT_EQ(expected, success); 115 // PostTask to quit the MessageLoop as this is called from D-Bus thread. 116 message_loop_.PostTask( 117 FROM_HERE, 118 base::Bind(&SignalSenderVerificationTest::OnOwnershipInternal, 119 base::Unretained(this))); 120 } 121 122 void OnOwnershipInternal() { 123 on_ownership_called_ = true; 124 run_loop_->Quit(); 125 } 126 127 void OnNameOwnerChanged(bool* called_flag, 128 const std::string& old_owner, 129 const std::string& new_owner) { 130 latest_name_owner_ = new_owner; 131 *called_flag = true; 132 run_loop_->Quit(); 133 } 134 135 // Called when the "Test" signal is received, in the main thread. 136 // Copy the string payload to |test_signal_string_|. 137 void OnTestSignal(Signal* signal) { 138 MessageReader reader(signal); 139 ASSERT_TRUE(reader.PopString(&test_signal_string_)); 140 run_loop_->Quit(); 141 } 142 143 // Called when connected to the signal. 144 void OnConnected(const std::string& interface_name, 145 const std::string& signal_name, 146 bool success) { 147 ASSERT_TRUE(success); 148 run_loop_->Quit(); 149 } 150 151 protected: 152 // Wait for the hey signal to be received. 153 void WaitForTestSignal() { 154 // OnTestSignal() will quit the message loop. 155 run_loop_.reset(new base::RunLoop); 156 run_loop_->Run(); 157 } 158 159 // Stopping a thread is considered an IO operation, so we need to fiddle with 160 // thread restrictions before and after calling Stop() on a TestService. 161 void SafeServiceStop(TestService* test_service) { 162 base::ThreadRestrictions::SetIOAllowed(true); 163 test_service->Stop(); 164 base::ThreadRestrictions::SetIOAllowed(false); 165 } 166 167 base::MessageLoop message_loop_; 168 scoped_ptr<base::RunLoop> run_loop_; 169 scoped_ptr<base::Thread> dbus_thread_; 170 scoped_refptr<Bus> bus_; 171 ObjectProxy* object_proxy_; 172 scoped_ptr<TestService> test_service_; 173 scoped_ptr<TestService> test_service2_; 174 // Text message from "Test" signal. 175 std::string test_signal_string_; 176 177 // The known latest name owner of TestService. Updated in OnNameOwnerChanged. 178 std::string latest_name_owner_; 179 180 // Boolean flags to record callback calls. 181 bool on_name_owner_changed_called_; 182 bool on_ownership_called_; 183 }; 184 185 TEST_F(SignalSenderVerificationTest, TestSignalAccepted) { 186 const char kMessage[] = "hello, world"; 187 // Send the test signal from the exported object. 188 test_service_->SendTestSignal(kMessage); 189 // Receive the signal with the object proxy. The signal is handled in 190 // SignalSenderVerificationTest::OnTestSignal() in the main thread. 191 WaitForTestSignal(); 192 ASSERT_EQ(kMessage, test_signal_string_); 193 } 194 195 // Disabled, http://crbug.com/407063 . 196 TEST_F(SignalSenderVerificationTest, DISABLED_TestSignalRejected) { 197 // To make sure the histogram instance is created. 198 UMA_HISTOGRAM_COUNTS("DBus.RejectedSignalCount", 0); 199 base::HistogramBase* reject_signal_histogram = 200 base::StatisticsRecorder::FindHistogram("DBus.RejectedSignalCount"); 201 scoped_ptr<base::HistogramSamples> samples1( 202 reject_signal_histogram->SnapshotSamples()); 203 204 const char kNewMessage[] = "hello, new world"; 205 test_service2_->SendTestSignal(kNewMessage); 206 207 // This test tests that our callback is NOT called by the ObjectProxy. 208 // Sleep to have message delivered to the client via the D-Bus service. 209 base::PlatformThread::Sleep(TestTimeouts::action_timeout()); 210 211 scoped_ptr<base::HistogramSamples> samples2( 212 reject_signal_histogram->SnapshotSamples()); 213 214 ASSERT_EQ("", test_signal_string_); 215 EXPECT_EQ(samples1->TotalCount() + 1, samples2->TotalCount()); 216 } 217 218 TEST_F(SignalSenderVerificationTest, TestOwnerChanged) { 219 const char kMessage[] = "hello, world"; 220 221 // Send the test signal from the exported object. 222 test_service_->SendTestSignal(kMessage); 223 // Receive the signal with the object proxy. The signal is handled in 224 // SignalSenderVerificationTest::OnTestSignal() in the main thread. 225 WaitForTestSignal(); 226 ASSERT_EQ(kMessage, test_signal_string_); 227 228 // Release and acquire the name ownership. 229 // latest_name_owner_ should be non empty as |test_service_| owns the name. 230 ASSERT_FALSE(latest_name_owner_.empty()); 231 test_service_->ShutdownAndBlock(); 232 // OnNameOwnerChanged will PostTask to quit the message loop. 233 run_loop_.reset(new base::RunLoop); 234 run_loop_->Run(); 235 // latest_name_owner_ should be empty as the owner is gone. 236 ASSERT_TRUE(latest_name_owner_.empty()); 237 238 // Reset the flag as NameOwnerChanged is already received in setup. 239 on_name_owner_changed_called_ = false; 240 on_ownership_called_ = false; 241 test_service2_->RequestOwnership( 242 base::Bind(&SignalSenderVerificationTest::OnOwnership, 243 base::Unretained(this), true)); 244 // Both of OnNameOwnerChanged() and OnOwnership() should quit the MessageLoop, 245 // but there's no expected order of those 2 event. 246 run_loop_.reset(new base::RunLoop); 247 run_loop_->Run(); 248 if (!on_name_owner_changed_called_ || !on_ownership_called_) { 249 run_loop_.reset(new base::RunLoop); 250 run_loop_->Run(); 251 } 252 ASSERT_TRUE(on_name_owner_changed_called_); 253 ASSERT_TRUE(on_ownership_called_); 254 255 // latest_name_owner_ becomes non empty as the new owner appears. 256 ASSERT_FALSE(latest_name_owner_.empty()); 257 258 // Now the second service owns the name. 259 const char kNewMessage[] = "hello, new world"; 260 261 test_service2_->SendTestSignal(kNewMessage); 262 WaitForTestSignal(); 263 ASSERT_EQ(kNewMessage, test_signal_string_); 264 } 265 266 TEST_F(SignalSenderVerificationTest, TestOwnerStealing) { 267 // Release and acquire the name ownership. 268 // latest_name_owner_ should be non empty as |test_service_| owns the name. 269 ASSERT_FALSE(latest_name_owner_.empty()); 270 test_service_->ShutdownAndBlock(); 271 // OnNameOwnerChanged will PostTask to quit the message loop. 272 run_loop_.reset(new base::RunLoop); 273 run_loop_->Run(); 274 // latest_name_owner_ should be empty as the owner is gone. 275 ASSERT_TRUE(latest_name_owner_.empty()); 276 // Reset the flag as NameOwnerChanged is already received in setup. 277 on_name_owner_changed_called_ = false; 278 279 // Start a test service that allows theft, using the D-Bus thread. 280 TestService::Options options; 281 options.dbus_task_runner = dbus_thread_->message_loop_proxy(); 282 options.request_ownership_options = Bus::REQUIRE_PRIMARY_ALLOW_REPLACEMENT; 283 TestService stealable_test_service(options); 284 ASSERT_TRUE(stealable_test_service.StartService()); 285 ASSERT_TRUE(stealable_test_service.WaitUntilServiceIsStarted()); 286 ASSERT_TRUE(stealable_test_service.HasDBusThread()); 287 ASSERT_TRUE(stealable_test_service.has_ownership()); 288 289 // OnNameOwnerChanged will PostTask to quit the message loop. 290 run_loop_.reset(new base::RunLoop); 291 run_loop_->Run(); 292 293 // Send a signal to check that the service is correctly owned. 294 const char kMessage[] = "hello, world"; 295 296 // Send the test signal from the exported object. 297 stealable_test_service.SendTestSignal(kMessage); 298 // Receive the signal with the object proxy. The signal is handled in 299 // SignalSenderVerificationTest::OnTestSignal() in the main thread. 300 WaitForTestSignal(); 301 ASSERT_EQ(kMessage, test_signal_string_); 302 303 // Reset the flag as NameOwnerChanged was called above. 304 on_name_owner_changed_called_ = false; 305 test_service2_->RequestOwnership( 306 base::Bind(&SignalSenderVerificationTest::OnOwnership, 307 base::Unretained(this), true)); 308 // Both of OnNameOwnerChanged() and OnOwnership() should quit the MessageLoop, 309 // but there's no expected order of those 2 event. 310 run_loop_.reset(new base::RunLoop); 311 run_loop_->Run(); 312 if (!on_name_owner_changed_called_ || !on_ownership_called_) { 313 run_loop_.reset(new base::RunLoop); 314 run_loop_->Run(); 315 } 316 ASSERT_TRUE(on_name_owner_changed_called_); 317 ASSERT_TRUE(on_ownership_called_); 318 319 // Now the second service owns the name. 320 const char kNewMessage[] = "hello, new world"; 321 322 test_service2_->SendTestSignal(kNewMessage); 323 WaitForTestSignal(); 324 ASSERT_EQ(kNewMessage, test_signal_string_); 325 326 SafeServiceStop(&stealable_test_service); 327 } 328 329 // Fails on Linux ChromiumOS Tests 330 TEST_F(SignalSenderVerificationTest, DISABLED_TestMultipleObjects) { 331 const char kMessage[] = "hello, world"; 332 333 ObjectProxy* object_proxy2 = bus_->GetObjectProxy( 334 "org.chromium.TestService", 335 ObjectPath("/org/chromium/DifferentObject")); 336 337 bool second_name_owner_changed_called = false; 338 object_proxy2->SetNameOwnerChangedCallback( 339 base::Bind(&SignalSenderVerificationTest::OnNameOwnerChanged, 340 base::Unretained(this), 341 &second_name_owner_changed_called)); 342 343 // Connect to a signal on the additional remote object to trigger the 344 // name owner matching. 345 object_proxy2->ConnectToSignal( 346 "org.chromium.DifferentTestInterface", 347 "Test", 348 base::Bind(&SignalSenderVerificationTest::OnTestSignal, 349 base::Unretained(this)), 350 base::Bind(&SignalSenderVerificationTest::OnConnected, 351 base::Unretained(this))); 352 // Wait until the object proxy is connected to the signal. 353 run_loop_.reset(new base::RunLoop); 354 run_loop_->Run(); 355 356 // Send the test signal from the exported object. 357 test_service_->SendTestSignal(kMessage); 358 // Receive the signal with the object proxy. The signal is handled in 359 // SignalSenderVerificationTest::OnTestSignal() in the main thread. 360 WaitForTestSignal(); 361 ASSERT_EQ(kMessage, test_signal_string_); 362 363 // Release and acquire the name ownership. 364 // latest_name_owner_ should be non empty as |test_service_| owns the name. 365 ASSERT_FALSE(latest_name_owner_.empty()); 366 test_service_->ShutdownAndBlock(); 367 // OnNameOwnerChanged will PostTask to quit the message loop. 368 run_loop_.reset(new base::RunLoop); 369 run_loop_->Run(); 370 // latest_name_owner_ should be empty as the owner is gone. 371 ASSERT_TRUE(latest_name_owner_.empty()); 372 373 // Reset the flag as NameOwnerChanged is already received in setup. 374 on_name_owner_changed_called_ = false; 375 second_name_owner_changed_called = false; 376 test_service2_->RequestOwnership( 377 base::Bind(&SignalSenderVerificationTest::OnOwnership, 378 base::Unretained(this), true)); 379 // Both of OnNameOwnerChanged() and OnOwnership() should quit the MessageLoop, 380 // but there's no expected order of those 2 event. 381 while (!on_name_owner_changed_called_ || !second_name_owner_changed_called || 382 !on_ownership_called_) { 383 run_loop_.reset(new base::RunLoop); 384 run_loop_->Run(); 385 } 386 ASSERT_TRUE(on_name_owner_changed_called_); 387 ASSERT_TRUE(second_name_owner_changed_called); 388 ASSERT_TRUE(on_ownership_called_); 389 390 // latest_name_owner_ becomes non empty as the new owner appears. 391 ASSERT_FALSE(latest_name_owner_.empty()); 392 393 // Now the second service owns the name. 394 const char kNewMessage[] = "hello, new world"; 395 396 test_service2_->SendTestSignal(kNewMessage); 397 WaitForTestSignal(); 398 ASSERT_EQ(kNewMessage, test_signal_string_); 399 } 400 401 } // namespace dbus 402
