update_engine: Switch to chrome-dbus for client requests in update_engine
update_engine daemon acts as DBus client to send DBus calls to shill,
power_manager and chrome, and to listen for signals from shill, chrome
and login_manager. This patch migrates these calls and signals to use
chrome-dbus framework instead of dbus-glib.
All references to dbus-glib code are removed.
BUG=chromium:419827
TEST=Updated unittest. Deployed on a link device and tested interactions with shill and chromium.
Change-Id: I31b389e0d1690cccb115ff3b6539c876ba81bd0e
Reviewed-on: https://chromium-review.googlesource.com/290990
Tested-by: Alex Deymo <deymo@chromium.org>
Reviewed-by: Alex Deymo <deymo@chromium.org>
Commit-Queue: Alex Deymo <deymo@chromium.org>
Trybot-Ready: Alex Deymo <deymo@chromium.org>
diff --git a/chrome_browser_proxy_resolver_unittest.cc b/chrome_browser_proxy_resolver_unittest.cc
index 3866358..62ee2e0 100644
--- a/chrome_browser_proxy_resolver_unittest.cc
+++ b/chrome_browser_proxy_resolver_unittest.cc
@@ -6,81 +6,171 @@
#include <deque>
#include <string>
+#include <vector>
#include <gtest/gtest.h>
#include <base/bind.h>
+#include <chromeos/make_unique_ptr.h>
#include <chromeos/message_loops/fake_message_loop.h>
-#include "update_engine/mock_dbus_wrapper.h"
+#include "update_engine/dbus_mocks.h"
+#include "update_engine/dbus_test_utils.h"
using ::testing::Return;
-using ::testing::SetArgPointee;
using ::testing::StrEq;
using ::testing::_;
using chromeos::MessageLoop;
+using org::chromium::LibCrosServiceInterfaceProxyMock;
+using org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxyMock;
using std::deque;
using std::string;
+using std::vector;
namespace chromeos_update_engine {
class ChromeBrowserProxyResolverTest : public ::testing::Test {
protected:
+ ChromeBrowserProxyResolverTest()
+ : service_interface_mock_(new LibCrosServiceInterfaceProxyMock()),
+ ue_proxy_resolved_interface_mock_(
+ new UpdateEngineLibcrosProxyResolvedInterfaceProxyMock()),
+ libcros_proxy_(
+ chromeos::make_unique_ptr(service_interface_mock_),
+ chromeos::make_unique_ptr(ue_proxy_resolved_interface_mock_)) {}
+
void SetUp() override {
loop_.SetAsCurrent();
+ // The ProxyResolved signal should be subscribed to.
+ MOCK_SIGNAL_HANDLER_EXPECT_SIGNAL_HANDLER(
+ ue_proxy_resolved_signal_,
+ *ue_proxy_resolved_interface_mock_,
+ ProxyResolved);
+
+ EXPECT_TRUE(resolver_.Init());
+ // Run the loop once to dispatch the successfully registered signal handler.
+ EXPECT_TRUE(loop_.RunOnce(false));
}
void TearDown() override {
EXPECT_FALSE(loop_.PendingTasks());
}
+ // Send the signal to the callback passed during registration of the
+ // ProxyResolved.
+ void SendReplySignal(const string& source_url,
+ const string& proxy_info,
+ const string& error_message);
+
+ void RunTest(bool chrome_replies, bool chrome_alive);
+
private:
chromeos::FakeMessageLoop loop_{nullptr};
+
+ // Local pointers to the mocks. The instances are owned by the
+ // |libcros_proxy_|.
+ LibCrosServiceInterfaceProxyMock* service_interface_mock_;
+ UpdateEngineLibcrosProxyResolvedInterfaceProxyMock*
+ ue_proxy_resolved_interface_mock_;
+
+ // The registered signal handler for the signal
+ // UpdateEngineLibcrosProxyResolvedInterface.ProxyResolved.
+ chromeos_update_engine::dbus_test_utils::MockSignalHandler<
+ void(const string&, const string&, const string&)>
+ ue_proxy_resolved_signal_;
+
+ LibCrosProxy libcros_proxy_;
+ ChromeBrowserProxyResolver resolver_{&libcros_proxy_};
};
+
+void ChromeBrowserProxyResolverTest::SendReplySignal(
+ const string& source_url,
+ const string& proxy_info,
+ const string& error_message) {
+ ASSERT_TRUE(ue_proxy_resolved_signal_.IsHandlerRegistered());
+ ue_proxy_resolved_signal_.signal_callback().Run(
+ source_url, proxy_info, error_message);
+}
+
+namespace {
+void CheckResponseResolved(const deque<string>& proxies,
+ void* /* pirv_data */) {
+ EXPECT_EQ(2, proxies.size());
+ EXPECT_EQ("socks5://192.168.52.83:5555", proxies[0]);
+ EXPECT_EQ(kNoProxy, proxies[1]);
+ MessageLoop::current()->BreakLoop();
+}
+
+void CheckResponseNoReply(const deque<string>& proxies, void* /* pirv_data */) {
+ EXPECT_EQ(1, proxies.size());
+ EXPECT_EQ(kNoProxy, proxies[0]);
+ MessageLoop::current()->BreakLoop();
+}
+} // namespace
+
+// chrome_replies should be set to whether or not we fake a reply from
+// chrome. If there's no reply, the resolver should time out.
+// If chrome_alive is false, assume that sending to chrome fails.
+void ChromeBrowserProxyResolverTest::RunTest(bool chrome_replies,
+ bool chrome_alive) {
+ char kUrl[] = "http://example.com/blah";
+ char kProxyConfig[] = "SOCKS5 192.168.52.83:5555;DIRECT";
+
+ EXPECT_CALL(*service_interface_mock_,
+ ResolveNetworkProxy(StrEq(kUrl),
+ StrEq(kLibCrosProxyResolveSignalInterface),
+ StrEq(kLibCrosProxyResolveName),
+ _,
+ _))
+ .WillOnce(Return(chrome_alive));
+
+ ProxiesResolvedFn get_proxies_response = &CheckResponseNoReply;
+ if (chrome_replies) {
+ get_proxies_response = &CheckResponseResolved;
+ MessageLoop::current()->PostDelayedTask(
+ FROM_HERE,
+ base::Bind(&ChromeBrowserProxyResolverTest::SendReplySignal,
+ base::Unretained(this),
+ kUrl,
+ kProxyConfig,
+ ""),
+ base::TimeDelta::FromSeconds(1));
+ }
+
+ EXPECT_TRUE(resolver_.GetProxiesForUrl(kUrl, get_proxies_response, nullptr));
+ MessageLoop::current()->Run();
+}
+
+
TEST_F(ChromeBrowserProxyResolverTest, ParseTest) {
// Test ideas from
// http://src.chromium.org/svn/trunk/src/net/proxy/proxy_list_unittest.cc
- const char* inputs[] = {
- "PROXY foopy:10",
- " DIRECT", // leading space.
- "PROXY foopy1 ; proxy foopy2;\t DIRECT",
- "proxy foopy1 ; SOCKS foopy2",
- "DIRECT ; proxy foopy1 ; DIRECT ; SOCKS5 foopy2;DIRECT ",
- "DIRECT ; proxy foopy1:80; DIRECT ; DIRECT",
- "PROXY-foopy:10",
- "PROXY",
- "PROXY foopy1 ; JUNK ; JUNK ; SOCKS5 foopy2 ; ;",
- "HTTP foopy1; SOCKS5 foopy2"
- };
- deque<string> outputs[arraysize(inputs)];
- outputs[0].push_back("http://foopy:10");
- outputs[0].push_back(kNoProxy);
- outputs[1].push_back(kNoProxy);
- outputs[2].push_back("http://foopy1");
- outputs[2].push_back("http://foopy2");
- outputs[2].push_back(kNoProxy);
- outputs[3].push_back("http://foopy1");
- outputs[3].push_back("socks4://foopy2");
- outputs[3].push_back(kNoProxy);
- outputs[4].push_back(kNoProxy);
- outputs[4].push_back("http://foopy1");
- outputs[4].push_back(kNoProxy);
- outputs[4].push_back("socks5://foopy2");
- outputs[4].push_back(kNoProxy);
- outputs[5].push_back(kNoProxy);
- outputs[5].push_back("http://foopy1:80");
- outputs[5].push_back(kNoProxy);
- outputs[5].push_back(kNoProxy);
- outputs[6].push_back(kNoProxy);
- outputs[7].push_back(kNoProxy);
- outputs[8].push_back("http://foopy1");
- outputs[8].push_back("socks5://foopy2");
- outputs[8].push_back(kNoProxy);
- outputs[9].push_back("socks5://foopy2");
- outputs[9].push_back(kNoProxy);
+ vector<string> inputs = {
+ "PROXY foopy:10",
+ " DIRECT", // leading space.
+ "PROXY foopy1 ; proxy foopy2;\t DIRECT",
+ "proxy foopy1 ; SOCKS foopy2",
+ "DIRECT ; proxy foopy1 ; DIRECT ; SOCKS5 foopy2;DIRECT ",
+ "DIRECT ; proxy foopy1:80; DIRECT ; DIRECT",
+ "PROXY-foopy:10",
+ "PROXY",
+ "PROXY foopy1 ; JUNK ; JUNK ; SOCKS5 foopy2 ; ;",
+ "HTTP foopy1; SOCKS5 foopy2"};
+ vector<deque<string>> outputs = {
+ {"http://foopy:10", kNoProxy},
+ {kNoProxy},
+ {"http://foopy1", "http://foopy2", kNoProxy},
+ {"http://foopy1", "socks4://foopy2", kNoProxy},
+ {kNoProxy, "http://foopy1", kNoProxy, "socks5://foopy2", kNoProxy},
+ {kNoProxy, "http://foopy1:80", kNoProxy, kNoProxy},
+ {kNoProxy},
+ {kNoProxy},
+ {"http://foopy1", "socks5://foopy2", kNoProxy},
+ {"socks5://foopy2", kNoProxy}};
+ ASSERT_EQ(inputs.size(), outputs.size());
- for (size_t i = 0; i < arraysize(inputs); i++) {
+ for (size_t i = 0; i < inputs.size(); i++) {
deque<string> results =
ChromeBrowserProxyResolver::ParseProxyString(inputs[i]);
deque<string>& expected = outputs[i];
@@ -93,110 +183,6 @@
}
}
-namespace {
-void DBusWrapperTestResolved(const deque<string>& proxies,
- void* /* pirv_data */) {
- EXPECT_EQ(2, proxies.size());
- EXPECT_EQ("socks5://192.168.52.83:5555", proxies[0]);
- EXPECT_EQ(kNoProxy, proxies[1]);
- MessageLoop::current()->BreakLoop();
-}
-void DBusWrapperTestResolvedNoReply(const deque<string>& proxies,
- void* /* pirv_data */) {
- EXPECT_EQ(1, proxies.size());
- EXPECT_EQ(kNoProxy, proxies[0]);
- MessageLoop::current()->BreakLoop();
-}
-
-void SendReply(DBusConnection* connection,
- DBusMessage* message,
- ChromeBrowserProxyResolver* resolver) {
- LOG(INFO) << "Calling SendReply";
- ChromeBrowserProxyResolver::StaticFilterMessage(connection,
- message,
- resolver);
-}
-
-// chrome_replies should be set to whether or not we fake a reply from
-// chrome. If there's no reply, the resolver should time out.
-// If chrome_alive is false, assume that sending to chrome fails.
-void RunTest(bool chrome_replies, bool chrome_alive) {
- intptr_t number = 1;
- DBusGConnection* kMockSystemGBus =
- reinterpret_cast<DBusGConnection*>(number++);
- DBusConnection* kMockSystemBus =
- reinterpret_cast<DBusConnection*>(number++);
- DBusGProxy* kMockDbusProxy =
- reinterpret_cast<DBusGProxy*>(number++);
- DBusMessage* kMockDbusMessage =
- reinterpret_cast<DBusMessage*>(number++);
-
- char kUrl[] = "http://example.com/blah";
- char kProxyConfig[] = "SOCKS5 192.168.52.83:5555;DIRECT";
-
- testing::StrictMock<MockDBusWrapper> dbus_iface;
-
- EXPECT_CALL(dbus_iface, BusGet(_, _))
- .Times(2)
- .WillRepeatedly(Return(kMockSystemGBus));
- EXPECT_CALL(dbus_iface,
- ConnectionGetConnection(kMockSystemGBus))
- .Times(2)
- .WillRepeatedly(Return(kMockSystemBus));
- EXPECT_CALL(dbus_iface, DBusBusAddMatch(kMockSystemBus, _, _));
- EXPECT_CALL(dbus_iface,
- DBusConnectionAddFilter(kMockSystemBus, _, _, _))
- .WillOnce(Return(1));
- EXPECT_CALL(dbus_iface,
- ProxyNewForName(kMockSystemGBus,
- StrEq(kLibCrosServiceName),
- StrEq(kLibCrosServicePath),
- StrEq(kLibCrosServiceInterface)))
- .WillOnce(Return(kMockDbusProxy));
- EXPECT_CALL(dbus_iface, ProxyUnref(kMockDbusProxy));
-
- EXPECT_CALL(dbus_iface, ProxyCall_3_0(
- kMockDbusProxy,
- StrEq(kLibCrosServiceResolveNetworkProxyMethodName),
- _,
- StrEq(kUrl),
- StrEq(kLibCrosProxyResolveSignalInterface),
- StrEq(kLibCrosProxyResolveName)))
- .WillOnce(Return(chrome_alive ? TRUE : FALSE));
-
- EXPECT_CALL(dbus_iface,
- DBusConnectionRemoveFilter(kMockSystemBus, _, _));
-
- if (chrome_replies) {
- EXPECT_CALL(dbus_iface,
- DBusMessageIsSignal(kMockDbusMessage,
- kLibCrosProxyResolveSignalInterface,
- kLibCrosProxyResolveName))
- .WillOnce(Return(1));
- EXPECT_CALL(dbus_iface,
- DBusMessageGetArgs_3(kMockDbusMessage, _, _, _, _))
- .WillOnce(DoAll(SetArgPointee<2>(static_cast<char*>(kUrl)),
- SetArgPointee<3>(static_cast<char*>(kProxyConfig)),
- Return(TRUE)));
- }
-
- ChromeBrowserProxyResolver resolver(&dbus_iface);
- EXPECT_EQ(true, resolver.Init());
- resolver.set_timeout(1);
- ProxiesResolvedFn get_proxies_response = &DBusWrapperTestResolvedNoReply;
-
- if (chrome_replies) {
- get_proxies_response = &DBusWrapperTestResolved;
- MessageLoop::current()->PostTask(
- FROM_HERE,
- base::Bind(&SendReply, kMockSystemBus, kMockDbusMessage, &resolver));
- }
-
- EXPECT_TRUE(resolver.GetProxiesForUrl(kUrl, get_proxies_response, nullptr));
- MessageLoop::current()->Run();
-}
-} // namespace
-
TEST_F(ChromeBrowserProxyResolverTest, SuccessTest) {
RunTest(true, true);
}