You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
395 lines
14 KiB
395 lines
14 KiB
// 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 <memory>
|
|
|
|
#include "base/bind.h"
|
|
#include "base/message_loop/message_loop.h"
|
|
#include "base/metrics/histogram_macros.h"
|
|
#include "base/metrics/histogram_samples.h"
|
|
#include "base/run_loop.h"
|
|
#include "base/single_thread_task_runner.h"
|
|
#include "base/test/test_timeouts.h"
|
|
#include "base/threading/platform_thread.h"
|
|
#include "base/threading/thread_restrictions.h"
|
|
#include "dbus/bus.h"
|
|
#include "dbus/message.h"
|
|
#include "dbus/object_proxy.h"
|
|
#include "dbus/test_service.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
namespace dbus {
|
|
|
|
// The test for sender verification in ObjectProxy.
|
|
class SignalSenderVerificationTest : public testing::Test {
|
|
public:
|
|
SignalSenderVerificationTest()
|
|
: on_name_owner_changed_called_(false),
|
|
on_ownership_called_(false) {
|
|
}
|
|
|
|
void SetUp() override {
|
|
// Make the main thread not to allow IO.
|
|
base::ThreadRestrictions::SetIOAllowed(false);
|
|
|
|
// Start the D-Bus thread.
|
|
dbus_thread_.reset(new base::Thread("D-Bus Thread"));
|
|
base::Thread::Options thread_options;
|
|
thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
|
|
ASSERT_TRUE(dbus_thread_->StartWithOptions(thread_options));
|
|
|
|
// Create the test service, using the D-Bus thread.
|
|
TestService::Options options;
|
|
options.dbus_task_runner = dbus_thread_->task_runner();
|
|
test_service_.reset(new TestService(options));
|
|
|
|
// Create the client, using the D-Bus thread.
|
|
Bus::Options bus_options;
|
|
bus_options.bus_type = Bus::SESSION;
|
|
bus_options.connection_type = Bus::PRIVATE;
|
|
bus_options.dbus_task_runner = dbus_thread_->task_runner();
|
|
bus_ = new Bus(bus_options);
|
|
object_proxy_ = bus_->GetObjectProxy(
|
|
test_service_->service_name(),
|
|
ObjectPath("/org/chromium/TestObject"));
|
|
ASSERT_TRUE(bus_->HasDBusThread());
|
|
|
|
object_proxy_->SetNameOwnerChangedCallback(
|
|
base::Bind(&SignalSenderVerificationTest::OnNameOwnerChanged,
|
|
base::Unretained(this),
|
|
&on_name_owner_changed_called_));
|
|
|
|
// Connect to the "Test" signal of "org.chromium.TestInterface" from
|
|
// the remote object.
|
|
object_proxy_->ConnectToSignal(
|
|
"org.chromium.TestInterface",
|
|
"Test",
|
|
base::Bind(&SignalSenderVerificationTest::OnTestSignal,
|
|
base::Unretained(this)),
|
|
base::Bind(&SignalSenderVerificationTest::OnConnected,
|
|
base::Unretained(this)));
|
|
// Wait until the object proxy is connected to the signal.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
|
|
// Start the test service.
|
|
ASSERT_TRUE(test_service_->StartService());
|
|
ASSERT_TRUE(test_service_->WaitUntilServiceIsStarted());
|
|
ASSERT_TRUE(test_service_->HasDBusThread());
|
|
ASSERT_TRUE(test_service_->has_ownership());
|
|
|
|
// Same setup for the second TestService. This service should not have the
|
|
// ownership of the name at this point.
|
|
options.service_name = test_service_->service_name();
|
|
test_service2_.reset(new TestService(options));
|
|
ASSERT_TRUE(test_service2_->StartService());
|
|
ASSERT_TRUE(test_service2_->WaitUntilServiceIsStarted());
|
|
ASSERT_TRUE(test_service2_->HasDBusThread());
|
|
ASSERT_FALSE(test_service2_->has_ownership());
|
|
|
|
// The name should be owned and known at this point.
|
|
if (!on_name_owner_changed_called_) {
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
}
|
|
ASSERT_FALSE(latest_name_owner_.empty());
|
|
}
|
|
|
|
void TearDown() override {
|
|
bus_->ShutdownOnDBusThreadAndBlock();
|
|
|
|
// Shut down the service.
|
|
test_service_->ShutdownAndBlock();
|
|
test_service2_->ShutdownAndBlock();
|
|
|
|
// Reset to the default.
|
|
base::ThreadRestrictions::SetIOAllowed(true);
|
|
|
|
// Stopping a thread is considered an IO operation, so do this after
|
|
// allowing IO.
|
|
test_service_->Stop();
|
|
test_service2_->Stop();
|
|
}
|
|
|
|
void OnOwnership(bool expected, bool success) {
|
|
ASSERT_EQ(expected, success);
|
|
// PostTask to quit the MessageLoop as this is called from D-Bus thread.
|
|
message_loop_.task_runner()->PostTask(
|
|
FROM_HERE,
|
|
base::Bind(&SignalSenderVerificationTest::OnOwnershipInternal,
|
|
base::Unretained(this)));
|
|
}
|
|
|
|
void OnOwnershipInternal() {
|
|
on_ownership_called_ = true;
|
|
run_loop_->Quit();
|
|
}
|
|
|
|
void OnNameOwnerChanged(bool* called_flag,
|
|
const std::string& old_owner,
|
|
const std::string& new_owner) {
|
|
latest_name_owner_ = new_owner;
|
|
*called_flag = true;
|
|
run_loop_->Quit();
|
|
}
|
|
|
|
// Called when the "Test" signal is received, in the main thread.
|
|
// Copy the string payload to |test_signal_string_|.
|
|
void OnTestSignal(Signal* signal) {
|
|
MessageReader reader(signal);
|
|
ASSERT_TRUE(reader.PopString(&test_signal_string_));
|
|
run_loop_->Quit();
|
|
}
|
|
|
|
// Called when connected to the signal.
|
|
void OnConnected(const std::string& interface_name,
|
|
const std::string& signal_name,
|
|
bool success) {
|
|
ASSERT_TRUE(success);
|
|
run_loop_->Quit();
|
|
}
|
|
|
|
protected:
|
|
// Wait for the hey signal to be received.
|
|
void WaitForTestSignal() {
|
|
// OnTestSignal() will quit the message loop.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
}
|
|
|
|
// Stopping a thread is considered an IO operation, so we need to fiddle with
|
|
// thread restrictions before and after calling Stop() on a TestService.
|
|
void SafeServiceStop(TestService* test_service) {
|
|
base::ThreadRestrictions::SetIOAllowed(true);
|
|
test_service->Stop();
|
|
base::ThreadRestrictions::SetIOAllowed(false);
|
|
}
|
|
|
|
base::MessageLoop message_loop_;
|
|
std::unique_ptr<base::RunLoop> run_loop_;
|
|
std::unique_ptr<base::Thread> dbus_thread_;
|
|
scoped_refptr<Bus> bus_;
|
|
ObjectProxy* object_proxy_;
|
|
std::unique_ptr<TestService> test_service_;
|
|
std::unique_ptr<TestService> test_service2_;
|
|
// Text message from "Test" signal.
|
|
std::string test_signal_string_;
|
|
|
|
// The known latest name owner of TestService. Updated in OnNameOwnerChanged.
|
|
std::string latest_name_owner_;
|
|
|
|
// Boolean flags to record callback calls.
|
|
bool on_name_owner_changed_called_;
|
|
bool on_ownership_called_;
|
|
};
|
|
|
|
TEST_F(SignalSenderVerificationTest, TestSignalAccepted) {
|
|
const char kMessage[] = "hello, world";
|
|
// Send the test signal from the exported object.
|
|
test_service_->SendTestSignal(kMessage);
|
|
// Receive the signal with the object proxy. The signal is handled in
|
|
// SignalSenderVerificationTest::OnTestSignal() in the main thread.
|
|
WaitForTestSignal();
|
|
ASSERT_EQ(kMessage, test_signal_string_);
|
|
}
|
|
|
|
TEST_F(SignalSenderVerificationTest, TestSignalRejected) {
|
|
const char kNewMessage[] = "hello, new world";
|
|
test_service2_->SendTestSignal(kNewMessage);
|
|
|
|
// This test tests that our callback is NOT called by the ObjectProxy.
|
|
// Sleep to have message delivered to the client via the D-Bus service.
|
|
base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
|
|
|
|
ASSERT_EQ("", test_signal_string_);
|
|
}
|
|
|
|
// Flaky. https://crbug.com/785555
|
|
TEST_F(SignalSenderVerificationTest, DISABLED_TestOwnerChanged) {
|
|
const char kMessage[] = "hello, world";
|
|
|
|
// Send the test signal from the exported object.
|
|
test_service_->SendTestSignal(kMessage);
|
|
// Receive the signal with the object proxy. The signal is handled in
|
|
// SignalSenderVerificationTest::OnTestSignal() in the main thread.
|
|
WaitForTestSignal();
|
|
ASSERT_EQ(kMessage, test_signal_string_);
|
|
|
|
// Release and acquire the name ownership.
|
|
// latest_name_owner_ should be non empty as |test_service_| owns the name.
|
|
ASSERT_FALSE(latest_name_owner_.empty());
|
|
test_service_->ShutdownAndBlock();
|
|
// OnNameOwnerChanged will PostTask to quit the message loop.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
// latest_name_owner_ should be empty as the owner is gone.
|
|
ASSERT_TRUE(latest_name_owner_.empty());
|
|
|
|
// Reset the flag as NameOwnerChanged is already received in setup.
|
|
on_name_owner_changed_called_ = false;
|
|
on_ownership_called_ = false;
|
|
test_service2_->RequestOwnership(
|
|
base::Bind(&SignalSenderVerificationTest::OnOwnership,
|
|
base::Unretained(this), true));
|
|
// Both of OnNameOwnerChanged() and OnOwnership() should quit the MessageLoop,
|
|
// but there's no expected order of those 2 event.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
if (!on_name_owner_changed_called_ || !on_ownership_called_) {
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
}
|
|
ASSERT_TRUE(on_name_owner_changed_called_);
|
|
ASSERT_TRUE(on_ownership_called_);
|
|
|
|
// latest_name_owner_ becomes non empty as the new owner appears.
|
|
ASSERT_FALSE(latest_name_owner_.empty());
|
|
|
|
// Now the second service owns the name.
|
|
const char kNewMessage[] = "hello, new world";
|
|
|
|
test_service2_->SendTestSignal(kNewMessage);
|
|
WaitForTestSignal();
|
|
ASSERT_EQ(kNewMessage, test_signal_string_);
|
|
}
|
|
|
|
// Flaky. https://crbug.com/785555
|
|
TEST_F(SignalSenderVerificationTest, DISABLED_TestOwnerStealing) {
|
|
// Release and acquire the name ownership.
|
|
// latest_name_owner_ should be non empty as |test_service_| owns the name.
|
|
ASSERT_FALSE(latest_name_owner_.empty());
|
|
test_service_->ShutdownAndBlock();
|
|
// OnNameOwnerChanged will PostTask to quit the message loop.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
// latest_name_owner_ should be empty as the owner is gone.
|
|
ASSERT_TRUE(latest_name_owner_.empty());
|
|
// Reset the flag as NameOwnerChanged is already received in setup.
|
|
on_name_owner_changed_called_ = false;
|
|
|
|
// Start a test service that allows theft, using the D-Bus thread.
|
|
TestService::Options options;
|
|
options.dbus_task_runner = dbus_thread_->task_runner();
|
|
options.request_ownership_options = Bus::REQUIRE_PRIMARY_ALLOW_REPLACEMENT;
|
|
options.service_name = test_service_->service_name();
|
|
TestService stealable_test_service(options);
|
|
ASSERT_TRUE(stealable_test_service.StartService());
|
|
ASSERT_TRUE(stealable_test_service.WaitUntilServiceIsStarted());
|
|
ASSERT_TRUE(stealable_test_service.HasDBusThread());
|
|
ASSERT_TRUE(stealable_test_service.has_ownership());
|
|
|
|
// OnNameOwnerChanged will PostTask to quit the message loop.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
|
|
// Send a signal to check that the service is correctly owned.
|
|
const char kMessage[] = "hello, world";
|
|
|
|
// Send the test signal from the exported object.
|
|
stealable_test_service.SendTestSignal(kMessage);
|
|
// Receive the signal with the object proxy. The signal is handled in
|
|
// SignalSenderVerificationTest::OnTestSignal() in the main thread.
|
|
WaitForTestSignal();
|
|
ASSERT_EQ(kMessage, test_signal_string_);
|
|
|
|
// Reset the flag as NameOwnerChanged was called above.
|
|
on_name_owner_changed_called_ = false;
|
|
test_service2_->RequestOwnership(
|
|
base::Bind(&SignalSenderVerificationTest::OnOwnership,
|
|
base::Unretained(this), true));
|
|
// Both of OnNameOwnerChanged() and OnOwnership() should quit the MessageLoop,
|
|
// but there's no expected order of those 2 event.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
if (!on_name_owner_changed_called_ || !on_ownership_called_) {
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
}
|
|
ASSERT_TRUE(on_name_owner_changed_called_);
|
|
ASSERT_TRUE(on_ownership_called_);
|
|
|
|
// Now the second service owns the name.
|
|
const char kNewMessage[] = "hello, new world";
|
|
|
|
test_service2_->SendTestSignal(kNewMessage);
|
|
WaitForTestSignal();
|
|
ASSERT_EQ(kNewMessage, test_signal_string_);
|
|
|
|
SafeServiceStop(&stealable_test_service);
|
|
}
|
|
|
|
// Fails on Linux ChromiumOS Tests
|
|
TEST_F(SignalSenderVerificationTest, DISABLED_TestMultipleObjects) {
|
|
const char kMessage[] = "hello, world";
|
|
|
|
ObjectProxy* object_proxy2 = bus_->GetObjectProxy(
|
|
test_service_->service_name(),
|
|
ObjectPath("/org/chromium/DifferentObject"));
|
|
|
|
bool second_name_owner_changed_called = false;
|
|
object_proxy2->SetNameOwnerChangedCallback(
|
|
base::Bind(&SignalSenderVerificationTest::OnNameOwnerChanged,
|
|
base::Unretained(this),
|
|
&second_name_owner_changed_called));
|
|
|
|
// Connect to a signal on the additional remote object to trigger the
|
|
// name owner matching.
|
|
object_proxy2->ConnectToSignal(
|
|
"org.chromium.DifferentTestInterface",
|
|
"Test",
|
|
base::Bind(&SignalSenderVerificationTest::OnTestSignal,
|
|
base::Unretained(this)),
|
|
base::Bind(&SignalSenderVerificationTest::OnConnected,
|
|
base::Unretained(this)));
|
|
// Wait until the object proxy is connected to the signal.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
|
|
// Send the test signal from the exported object.
|
|
test_service_->SendTestSignal(kMessage);
|
|
// Receive the signal with the object proxy. The signal is handled in
|
|
// SignalSenderVerificationTest::OnTestSignal() in the main thread.
|
|
WaitForTestSignal();
|
|
ASSERT_EQ(kMessage, test_signal_string_);
|
|
|
|
// Release and acquire the name ownership.
|
|
// latest_name_owner_ should be non empty as |test_service_| owns the name.
|
|
ASSERT_FALSE(latest_name_owner_.empty());
|
|
test_service_->ShutdownAndBlock();
|
|
// OnNameOwnerChanged will PostTask to quit the message loop.
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
// latest_name_owner_ should be empty as the owner is gone.
|
|
ASSERT_TRUE(latest_name_owner_.empty());
|
|
|
|
// Reset the flag as NameOwnerChanged is already received in setup.
|
|
on_name_owner_changed_called_ = false;
|
|
second_name_owner_changed_called = false;
|
|
test_service2_->RequestOwnership(
|
|
base::Bind(&SignalSenderVerificationTest::OnOwnership,
|
|
base::Unretained(this), true));
|
|
// Both of OnNameOwnerChanged() and OnOwnership() should quit the MessageLoop,
|
|
// but there's no expected order of those 2 event.
|
|
while (!on_name_owner_changed_called_ || !second_name_owner_changed_called ||
|
|
!on_ownership_called_) {
|
|
run_loop_.reset(new base::RunLoop);
|
|
run_loop_->Run();
|
|
}
|
|
ASSERT_TRUE(on_name_owner_changed_called_);
|
|
ASSERT_TRUE(second_name_owner_changed_called);
|
|
ASSERT_TRUE(on_ownership_called_);
|
|
|
|
// latest_name_owner_ becomes non empty as the new owner appears.
|
|
ASSERT_FALSE(latest_name_owner_.empty());
|
|
|
|
// Now the second service owns the name.
|
|
const char kNewMessage[] = "hello, new world";
|
|
|
|
test_service2_->SendTestSignal(kNewMessage);
|
|
WaitForTestSignal();
|
|
ASSERT_EQ(kNewMessage, test_signal_string_);
|
|
}
|
|
|
|
} // namespace dbus
|