Skip to content

GitLab

T
tangled
Commit 86e2015d authored by adamk@chromium.org's avatar adamk@chromium.org
Browse files
Options

Revert "Offline state detection for linux, using new D-Bus library." 

This reverts commit b383640d.

Broke the Linux shared build.

BUG=53473
TBR=willchan

Review URL: http://codereview.chromium.org/8578013

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@110346 0039d316-1c4b-4281-b951-d872f2087c98
parent 9ed24fef
Hide whitespace changes
Inline Side-by-side
Showing with 12 additions and 487 deletions
net/DEPS
View file @ 86e2015d
include_rules = [
"+crypto",
"+dbus",
"+jni",
"+third_party/apple_apsl",
"+third_party/libevent",
......
net/base/network_change_notifier.cc
View file @ 86e2015d
......@@ -60,7 +60,7 @@ NetworkChangeNotifier* NetworkChangeNotifier::Create() {
CHECK(false);
return NULL;
#elif defined(OS_LINUX) || defined(OS_ANDROID)
return NetworkChangeNotifierLinux::Create();
return new NetworkChangeNotifierLinux();
#elif defined(OS_MACOSX)
return new NetworkChangeNotifierMac();
#else
......
net/base/network_change_notifier.h
View file @ 86e2015d
......@@ -136,7 +136,6 @@ class NET_EXPORT NetworkChangeNotifier {
static void NotifyObserversOfDNSChange();
private:
friend class NetworkChangeNotifierLinuxTest;
friend class NetworkChangeNotifierWinTest;
// Allows a second NetworkChangeNotifier to be created for unit testing, so
......
net/base/network_change_notifier_linux.cc
View file @ 86e2015d
// Copyright (c) 2011 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.
//
// This implementation of NetworkChangeNotifier's offline state detection
// depends on D-Bus and NetworkManager, and is known to work on at least
// GNOME version 2.30. If D-Bus or NetworkManager are unavailable, this
// implementation will always behave as if it is online.
#include "net/base/network_change_notifier_linux.h"
......@@ -20,13 +15,7 @@
#include "base/file_util.h"
#include "base/files/file_path_watcher.h"
#include "base/memory/weak_ptr.h"
#include "base/synchronization/lock.h"
#include "base/synchronization/waitable_event.h"
#include "base/threading/platform_thread.h"
#include "base/threading/thread.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_proxy.h"
#include "net/base/net_errors.h"
#include "net/base/network_change_notifier_netlink_linux.h"
......@@ -38,190 +27,6 @@ namespace {
const int kInvalidSocket = -1;
const char kNetworkManagerServiceName[] = "org.freedesktop.NetworkManager";
const char kNetworkManagerPath[] = "/org/freedesktop/NetworkManager";
const char kNetworkManagerInterface[] = "org.freedesktop.NetworkManager";
// http://projects.gnome.org/NetworkManager/developers/spec-08.html#type-NM_STATE
enum {
NM_LEGACY_STATE_UNKNOWN = 0,
NM_LEGACY_STATE_ASLEEP = 1,
NM_LEGACY_STATE_CONNECTING = 2,
NM_LEGACY_STATE_CONNECTED = 3,
NM_LEGACY_STATE_DISCONNECTED = 4
};
// http://projects.gnome.org/NetworkManager/developers/migrating-to-09/spec.html#type-NM_STATE
enum {
NM_STATE_UNKNOWN = 0,
NM_STATE_ASLEEP = 10,
NM_STATE_DISCONNECTED = 20,
NM_STATE_DISCONNECTING = 30,
NM_STATE_CONNECTING = 40,
NM_STATE_CONNECTED_LOCAL = 50,
NM_STATE_CONNECTED_SITE = 60,
NM_STATE_CONNECTED_GLOBAL = 70
};
// A wrapper around NetworkManager's D-Bus API.
class NetworkManagerApi {
public:
NetworkManagerApi(const base::Closure& notification_callback, dbus::Bus* bus)
: is_offline_(false),
offline_state_initialized_(true /*manual_reset*/, false),
notification_callback_(notification_callback),
helper_thread_id_(base::kInvalidThreadId),
ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)),
system_bus_(bus) { }
~NetworkManagerApi() { }
// Should be called on a helper thread which must be of type IO.
void Init();
// Must be called by the helper thread's CleanUp() method.
void CleanUp();
// Implementation of NetworkChangeNotifierLinux::IsCurrentlyOffline().
// Safe to call from any thread, but will block until Init() has completed.
bool IsCurrentlyOffline();
private:
// Callbacks for D-Bus API.
void OnStateChanged(dbus::Message* message);
void OnResponse(dbus::Response* response) {
OnStateChanged(response);
offline_state_initialized_.Signal();
}
void OnSignaled(dbus::Signal* signal) {
OnStateChanged(signal);
}
void OnConnected(const std::string&, const std::string&, bool success) {
if (!success) {
DLOG(WARNING) << "Failed to set up offline state detection";
offline_state_initialized_.Signal();
}
}
// Converts a NetworkManager state uint to a bool.
static bool StateIsOffline(uint32 state);
bool is_offline_;
base::Lock is_offline_lock_;
base::WaitableEvent offline_state_initialized_;
base::Closure notification_callback_;
base::PlatformThreadId helper_thread_id_;
base::WeakPtrFactory<NetworkManagerApi> ptr_factory_;
scoped_refptr<dbus::Bus> system_bus_;
DISALLOW_COPY_AND_ASSIGN(NetworkManagerApi);
};
void NetworkManagerApi::Init() {
// D-Bus requires an IO MessageLoop.
DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_IO);
helper_thread_id_ = base::PlatformThread::CurrentId();
if (!system_bus_) {
dbus::Bus::Options options;
options.bus_type = dbus::Bus::SYSTEM;
options.connection_type = dbus::Bus::PRIVATE;
system_bus_ = new dbus::Bus(options);
}
dbus::ObjectProxy* proxy =
system_bus_->GetObjectProxy(kNetworkManagerServiceName,
kNetworkManagerPath);
// Get the initial state asynchronously.
dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES, "Get");
dbus::MessageWriter builder(&method_call);
builder.AppendString(kNetworkManagerInterface);
builder.AppendString("State");
proxy->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&NetworkManagerApi::OnResponse, ptr_factory_.GetWeakPtr()));
// And sign up for notifications.
proxy->ConnectToSignal(
kNetworkManagerInterface,
"StateChanged",
base::Bind(&NetworkManagerApi::OnSignaled, ptr_factory_.GetWeakPtr()),
base::Bind(&NetworkManagerApi::OnConnected, ptr_factory_.GetWeakPtr()));
}
void NetworkManagerApi::CleanUp() {
DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
ptr_factory_.InvalidateWeakPtrs();
}
void NetworkManagerApi::OnStateChanged(dbus::Message* message) {
DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
if (!message) {
DLOG(WARNING) << "No response received for initial state request";
return;
}
dbus::MessageReader reader(message);
uint32 state = 0;
if (!reader.HasMoreData() || !reader.PopUint32(&state)) {
DLOG(WARNING) << "Unexpected response for NetworkManager State request: "
<< message->ToString();
return;
}
bool new_is_offline = StateIsOffline(state);
{
base::AutoLock lock(is_offline_lock_);
if (is_offline_ != new_is_offline)
is_offline_ = new_is_offline;
else
return;
}
if (offline_state_initialized_.IsSignaled())
notification_callback_.Run();
}
bool NetworkManagerApi::StateIsOffline(uint32 state) {
switch (state) {
case NM_LEGACY_STATE_CONNECTED:
case NM_STATE_CONNECTED_SITE:
case NM_STATE_CONNECTED_GLOBAL:
// Definitely connected
return false;
case NM_LEGACY_STATE_DISCONNECTED:
case NM_STATE_DISCONNECTED:
// Definitely disconnected
return true;
case NM_STATE_CONNECTED_LOCAL:
// Local networking only; I'm treating this as offline (keybuk)
return true;
case NM_LEGACY_STATE_CONNECTING:
case NM_STATE_DISCONNECTING:
case NM_STATE_CONNECTING:
// In-flight change to connection status currently underway
return true;
case NM_LEGACY_STATE_ASLEEP:
case NM_STATE_ASLEEP:
// Networking disabled or no devices on system
return true;
default:
// Unknown status
return false;
}
}
bool NetworkManagerApi::IsCurrentlyOffline() {
offline_state_initialized_.Wait();
base::AutoLock lock(is_offline_lock_);
return is_offline_;
}
class DNSWatchDelegate : public FilePathWatcher::Delegate {
public:
explicit DNSWatchDelegate(const base::Closure& callback)
......@@ -249,19 +54,13 @@ void DNSWatchDelegate::OnFilePathError(const FilePath& path) {
class NetworkChangeNotifierLinux::Thread
: public base::Thread, public MessageLoopForIO::Watcher {
public:
explicit Thread(dbus::Bus* bus);
Thread();
virtual ~Thread();
// MessageLoopForIO::Watcher:
virtual void OnFileCanReadWithoutBlocking(int fd);
virtual void OnFileCanWriteWithoutBlocking(int /* fd */);
// Plumbing for NetworkChangeNotifier::IsCurrentlyOffline.
// Safe to call from any thread.
bool IsCurrentlyOffline() {
return network_manager_api_.IsCurrentlyOffline();
}
protected:
// base::Thread
virtual void Init();
......@@ -272,14 +71,10 @@ class NetworkChangeNotifierLinux::Thread
NetworkChangeNotifier::NotifyObserversOfIPAddressChange();
}
static void NotifyObserversOfDNSChange() {
void NotifyObserversOfDNSChange() {
NetworkChangeNotifier::NotifyObserversOfDNSChange();
}
static void NotifyObserversOfOnlineStateChange() {
NetworkChangeNotifier::NotifyObserversOfOnlineStateChange();
}
// Starts listening for netlink messages. Also handles the messages if there
// are any available on the netlink socket.
void ListenForNotifications();
......@@ -301,20 +96,13 @@ class NetworkChangeNotifierLinux::Thread
scoped_ptr<base::files::FilePathWatcher> hosts_file_watcher_;
scoped_refptr<DNSWatchDelegate> file_watcher_delegate_;
// Used to detect online/offline state changes.
NetworkManagerApi network_manager_api_;
DISALLOW_COPY_AND_ASSIGN(Thread);
};
NetworkChangeNotifierLinux::Thread::Thread(dbus::Bus* bus)
NetworkChangeNotifierLinux::Thread::Thread()
: base::Thread("NetworkChangeNotifier"),
netlink_fd_(kInvalidSocket),
ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)),
network_manager_api_(
base::Bind(&NetworkChangeNotifierLinux::Thread
::NotifyObserversOfOnlineStateChange),
bus) {
ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
}
NetworkChangeNotifierLinux::Thread::~Thread() {
......@@ -325,7 +113,8 @@ void NetworkChangeNotifierLinux::Thread::Init() {
resolv_file_watcher_.reset(new FilePathWatcher);
hosts_file_watcher_.reset(new FilePathWatcher);
file_watcher_delegate_ = new DNSWatchDelegate(base::Bind(
&NetworkChangeNotifierLinux::Thread::NotifyObserversOfDNSChange));
&NetworkChangeNotifierLinux::Thread::NotifyObserversOfDNSChange,
base::Unretained(this)));
if (!resolv_file_watcher_->Watch(
FilePath(FILE_PATH_LITERAL("/etc/resolv.conf")),
file_watcher_delegate_.get())) {
......@@ -341,8 +130,6 @@ void NetworkChangeNotifierLinux::Thread::Init() {
return;
}
ListenForNotifications();
network_manager_api_.Init();
}
void NetworkChangeNotifierLinux::Thread::CleanUp() {
......@@ -356,8 +143,6 @@ void NetworkChangeNotifierLinux::Thread::CleanUp() {
// into us via the delegate during destruction.
resolv_file_watcher_.reset();
hosts_file_watcher_.reset();
network_manager_api_.CleanUp();
}
void NetworkChangeNotifierLinux::Thread::OnFileCanReadWithoutBlocking(int fd) {
......@@ -421,17 +206,8 @@ int NetworkChangeNotifierLinux::Thread::ReadNotificationMessage(
return ERR_IO_PENDING;
}
NetworkChangeNotifierLinux* NetworkChangeNotifierLinux::Create() {
return new NetworkChangeNotifierLinux(NULL);
}
NetworkChangeNotifierLinux* NetworkChangeNotifierLinux::CreateForTest(
dbus::Bus* bus) {
return new NetworkChangeNotifierLinux(bus);
}
NetworkChangeNotifierLinux::NetworkChangeNotifierLinux(dbus::Bus* bus)
: notifier_thread_(new Thread(bus)) {
NetworkChangeNotifierLinux::NetworkChangeNotifierLinux()
: notifier_thread_(new Thread) {
// We create this notifier thread because the notification implementation
// needs a MessageLoopForIO, and there's no guarantee that
// MessageLoop::current() meets that criterion.
......@@ -446,7 +222,8 @@ NetworkChangeNotifierLinux::~NetworkChangeNotifierLinux() {
}
bool NetworkChangeNotifierLinux::IsCurrentlyOffline() const {
return notifier_thread_->IsCurrentlyOffline();
// TODO(eroman): http://crbug.com/53473
return false;
}
} // namespace net
net/base/network_change_notifier_linux.h
View file @ 86e2015d
......@@ -11,23 +11,15 @@
#include "base/memory/scoped_ptr.h"
#include "net/base/network_change_notifier.h"
namespace dbus {
class Bus;
}
namespace net {
class NetworkChangeNotifierLinux : public NetworkChangeNotifier {
public:
static NetworkChangeNotifierLinux* Create();
// Unittests inject a mock bus.
static NetworkChangeNotifierLinux* CreateForTest(dbus::Bus* bus);
NetworkChangeNotifierLinux();
private:
class Thread;
explicit NetworkChangeNotifierLinux(dbus::Bus* bus);
virtual ~NetworkChangeNotifierLinux();
// NetworkChangeNotifier:
......
net/base/network_change_notifier_linux_unittest.cc deleted 100644 → 0
View file @ 9ed24fef
// Copyright (c) 2011 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 "net/base/network_change_notifier_linux.h"
#include "base/bind.h"
#include "base/message_loop_proxy.h"
#include "base/synchronization/waitable_event.h"
#include "dbus/mock_bus.h"
#include "dbus/mock_object_proxy.h"
#include "dbus/message.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
using testing::_;
using testing::DoAll;
using testing::InvokeWithoutArgs;
using testing::Return;
using testing::SaveArg;
class NetworkChangeNotifierLinuxTest : public testing::Test {
protected:
// A subset of the NetworkManager-defined constants used in
// the tests below. See network_change_notifier_linux.cc
// for the full list.
enum {
NM_STATE_DISCONNECTED = 20,
NM_STATE_DISCONNECTING = 30,
NM_STATE_CONNECTED_SITE = 70,
NM_STATE_CONNECTED_GLOBAL = 70
};
NetworkChangeNotifierLinuxTest()
: initialized_(false, false) {}
virtual void SetUp() {
dbus::Bus::Options options;
options.bus_type = dbus::Bus::SYSTEM;
mock_bus_ = new dbus::MockBus(options);
mock_object_proxy_ = new dbus::MockObjectProxy(mock_bus_.get(),
"service_name",
"service_path");
EXPECT_CALL(*mock_bus_, GetObjectProxy(_, _))
.WillOnce(Return(mock_object_proxy_.get()));
EXPECT_CALL(*mock_object_proxy_, CallMethod(_, _, _))
.WillOnce(SaveArg<2>(&response_callback_));
EXPECT_CALL(*mock_object_proxy_, ConnectToSignal(_, _, _, _))
.WillOnce(
DoAll(
SaveArg<2>(&signal_callback_),
InvokeWithoutArgs(
this,
&NetworkChangeNotifierLinuxTest::Initialize)));
notifier_.reset(NetworkChangeNotifierLinux::CreateForTest(mock_bus_.get()));
initialized_.Wait();
}
void Initialize() {
notifier_thread_proxy_ = base::MessageLoopProxy::current();
initialized_.Signal();
}
void RunOnNotifierThread(const base::Closure& callback) {
base::WaitableEvent event(false, false);
notifier_thread_proxy_->PostTask(FROM_HERE, base::Bind(
&RunOnNotifierThreadHelper, callback, &event));
event.Wait();
// Run any tasks queued on the main thread, e.g. by
// ObserverListThreadSafe.
MessageLoop::current()->RunAllPending();
}
void SendResponse(uint32 state) {
scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
dbus::MessageWriter writer(response.get());
writer.AppendUint32(state);
RunOnNotifierThread(base::Bind(response_callback_, response.get()));
}
void SendSignal(uint32 state) {
dbus::Signal signal("org.freedesktop.NetworkManager", "StateChanged");
dbus::MessageWriter writer(&signal);
writer.AppendUint32(state);
RunOnNotifierThread(base::Bind(signal_callback_, &signal));
}
dbus::ObjectProxy::ResponseCallback response_callback_;
dbus::ObjectProxy::SignalCallback signal_callback_;
// Allows creating a new NetworkChangeNotifier. Must be created before
// |notifier_| and destroyed after it to avoid DCHECK failures.
NetworkChangeNotifier::DisableForTest disable_for_test_;
scoped_ptr<NetworkChangeNotifier> notifier_;
private:
static void RunOnNotifierThreadHelper(const base::Closure& callback,
base::WaitableEvent* event) {
callback.Run();
event->Signal();
}
base::WaitableEvent initialized_;
// Valid only after initialized_ is signaled.
scoped_refptr<base::MessageLoopProxy> notifier_thread_proxy_;
scoped_refptr<dbus::MockBus> mock_bus_;
scoped_refptr<dbus::MockObjectProxy> mock_object_proxy_;
};
namespace {
class OfflineObserver : public NetworkChangeNotifier::OnlineStateObserver {
public:
OfflineObserver()
: notification_count(0),
last_online_value(true) {
NetworkChangeNotifier::AddOnlineStateObserver(this);
}
~OfflineObserver() {
NetworkChangeNotifier::RemoveOnlineStateObserver(this);
}
virtual void OnOnlineStateChanged(bool online) OVERRIDE {
notification_count++;
last_online_value = online;
}
int notification_count;
bool last_online_value;
};
TEST_F(NetworkChangeNotifierLinuxTest, Offline) {
SendResponse(NM_STATE_DISCONNECTED);
EXPECT_TRUE(NetworkChangeNotifier::IsOffline());
}
TEST_F(NetworkChangeNotifierLinuxTest, Online) {
SendResponse(NM_STATE_CONNECTED_GLOBAL);
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
}
TEST_F(NetworkChangeNotifierLinuxTest, OfflineThenOnline) {
OfflineObserver observer;
SendResponse(NM_STATE_DISCONNECTED);
EXPECT_TRUE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(0, observer.notification_count);
SendSignal(NM_STATE_CONNECTED_GLOBAL);
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(1, observer.notification_count);
EXPECT_TRUE(observer.last_online_value);
}
TEST_F(NetworkChangeNotifierLinuxTest, MultipleStateChanges) {
OfflineObserver observer;
SendResponse(NM_STATE_CONNECTED_GLOBAL);
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(0, observer.notification_count);
SendSignal(NM_STATE_DISCONNECTED);
EXPECT_TRUE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(1, observer.notification_count);
EXPECT_FALSE(observer.last_online_value);
SendSignal(NM_STATE_CONNECTED_GLOBAL);
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(2, observer.notification_count);
EXPECT_TRUE(observer.last_online_value);
}
TEST_F(NetworkChangeNotifierLinuxTest, IgnoreContinuedOnlineState) {
OfflineObserver observer;
SendResponse(NM_STATE_CONNECTED_SITE);
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(0, observer.notification_count);
SendSignal(NM_STATE_CONNECTED_GLOBAL);
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(0, observer.notification_count);
}
TEST_F(NetworkChangeNotifierLinuxTest, IgnoreContinuedOfflineState) {
OfflineObserver observer;
SendResponse(NM_STATE_DISCONNECTING);
EXPECT_TRUE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(0, observer.notification_count);
SendSignal(NM_STATE_DISCONNECTED);
EXPECT_TRUE(NetworkChangeNotifier::IsOffline());
EXPECT_EQ(0, observer.notification_count);
}
TEST_F(NetworkChangeNotifierLinuxTest, NullResponse) {
RunOnNotifierThread(base::Bind(
response_callback_, static_cast<dbus::Response*>(NULL)));
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
}
TEST_F(NetworkChangeNotifierLinuxTest, EmptyResponse) {
scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
RunOnNotifierThread(base::Bind(response_callback_, response.get()));
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
}
TEST_F(NetworkChangeNotifierLinuxTest, InvalidResponse) {
scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
dbus::MessageWriter writer(response.get());
writer.AppendUint16(20); // Uint16 instead of the expected Uint32
RunOnNotifierThread(base::Bind(response_callback_, response.get()));
EXPECT_FALSE(NetworkChangeNotifier::IsOffline());
}
} // namespace
} // namespace net
net/net.gyp
View file @ 86e2015d
......@@ -939,13 +939,6 @@
],
},
],
[ 'OS == "linux"', {
'dependencies': [
'../build/linux/system.gyp:dbus',
'../dbus/dbus.gyp:dbus',
],
},
],
],
},
{
......@@ -996,7 +989,6 @@
'base/net_log_unittest.cc',
'base/net_log_unittest.h',
'base/net_util_unittest.cc',
'base/network_change_notifier_linux_unittest.cc',
'base/network_change_notifier_win_unittest.cc',
'base/origin_bound_cert_service_unittest.cc',
'base/pem_tokenizer_unittest.cc',
......@@ -1232,13 +1224,6 @@
],
},
],
[ 'OS == "linux"', {
'dependencies': [
'../build/linux/system.gyp:dbus',
'../dbus/dbus.gyp:dbus_test_support',
],
},
],
],
},
{
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment