0

- Adding a new ManagedNetworkConfigurationHandler.

- Adapting the NetworkingPrivate extension API to use the new handler if it's available.
- Changing explicit ownership of NetworkConfigurationHandler to singleton.
- Adding gspencer@ and me as owners.

The new handler will be responsible to
- enforce network policies
- handle shared vs. non-shared network configuration

Compared to the NetworkConfigurationHandler, this handler shouldn't use Shill properties but ONC wherever possible.

TBR=zelidrag@chromium.org (for gypi change)
BUG=157696,148353

Review URL: https://chromiumcodereview.appspot.com/12211103

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@184933 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
pneubeck@chromium.org
2013-02-27 12:19:28 +00:00
parent f1d7a4f0cf
commit cdbea94e52
15 changed files with 468 additions and 66 deletions

@@ -49,6 +49,7 @@
#include "chrome/browser/chromeos/memory/oom_priority_manager.h"
#include "chrome/browser/chromeos/net/connectivity_state_helper.h"
#include "chrome/browser/chromeos/net/cros_network_change_notifier_factory.h"
#include "chrome/browser/chromeos/net/managed_network_configuration_handler.h"
#include "chrome/browser/chromeos/net/network_change_notifier_network_library.h"
#include "chrome/browser/chromeos/net/network_portal_detector.h"
#include "chrome/browser/chromeos/power/brightness_observer.h"
@@ -260,7 +261,12 @@ class DBusServices {
chromeos::network_event_log::Initialize();
chromeos::GeolocationHandler::Initialize();
chromeos::NetworkStateHandler::Initialize();
chromeos::NetworkConfigurationHandler::Initialize();
if (CommandLine::ForCurrentProcess()->HasSwitch(
chromeos::switches::kEnableNewNetworkConfigurationHandlers)) {
chromeos::NetworkConfigurationHandler::Initialize();
chromeos::ManagedNetworkConfigurationHandler::Initialize();
}
// Initialize the network change notifier for Chrome OS. The network
// change notifier starts to monitor changes from the power manager and
@@ -298,9 +304,14 @@ class DBusServices {
if (cros_initialized_ && CrosLibrary::Get())
CrosLibrary::Shutdown();
if (CommandLine::ForCurrentProcess()->HasSwitch(
chromeos::switches::kEnableNewNetworkConfigurationHandlers)) {
chromeos::ManagedNetworkConfigurationHandler::Shutdown();
chromeos::NetworkConfigurationHandler::Shutdown();
}
chromeos::ConnectivityStateHelper::Shutdown();
chromeos::NetworkStateHandler::Shutdown();
chromeos::NetworkConfigurationHandler::Shutdown();
chromeos::GeolocationHandler::Shutdown();
chromeos::network_event_log::Shutdown();

@@ -4,7 +4,10 @@
#include "chrome/browser/chromeos/extensions/networking_private_api.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/callback.h"
#include "chrome/browser/chromeos/net/managed_network_configuration_handler.h"
#include "chrome/browser/extensions/extension_function_registry.h"
#include "chrome/common/extensions/api/networking_private.h"
#include "chromeos/dbus/dbus_thread_manager.h"
@@ -25,17 +28,10 @@ namespace {
// An error returned when no valid services were found.
const char kInvalidResponseError[] = "Error.invalidResponse";
// This creates a new ONC dictionary that only contains the information we're
// interested in passing on to JavaScript.
// Filters from the given ONC dictionary the information we're interested in
// before passing it to JavaScript.
scoped_ptr<api::NetworkProperties> CreateFilteredResult(
const base::DictionaryValue& properties) {
scoped_ptr<base::DictionaryValue> onc_properties(
onc::TranslateShillServiceToONCPart(
properties,
&onc::kNetworkConfigurationSignature));
// Now we filter it so we only include properties that we care about for this
// interface.
const base::DictionaryValue& onc_dictionary) {
static const char* const desired_fields[] = {
onc::network_config::kWiFi,
onc::network_config::kName,
@@ -47,10 +43,12 @@ scoped_ptr<api::NetworkProperties> CreateFilteredResult(
scoped_ptr<api::NetworkProperties> filtered_result(
new api::NetworkProperties);
for (size_t i = 0; i < arraysize(desired_fields); ++i) {
base::Value* value;
if (onc_properties->Get(desired_fields[i], &value))
filtered_result->additional_properties.Set(desired_fields[i],
value->DeepCopy());
const base::Value* value;
if (onc_dictionary.GetWithoutPathExpansion(desired_fields[i], &value)) {
filtered_result->additional_properties.SetWithoutPathExpansion(
desired_fields[i],
value->DeepCopy());
}
}
return filtered_result.Pass();
@@ -141,8 +139,13 @@ void ResultList::ServicePropertiesCallback(
DBusMethodCallStatus call_status,
const base::DictionaryValue& result) {
if (call_status == DBUS_METHOD_CALL_SUCCESS) {
scoped_ptr<base::DictionaryValue> onc_properties(
onc::TranslateShillServiceToONCPart(
result,
&onc::kNetworkConfigurationSignature));
scoped_ptr<api::NetworkProperties> filtered_result(
CreateFilteredResult(result));
CreateFilteredResult(*onc_properties));
std::string onc_type;
if (filtered_result->additional_properties.GetString(
@@ -155,7 +158,7 @@ void ResultList::ServicePropertiesCallback(
// this line so that we're sending back the actual GUID. The
// JavaScript shouldn't care: this ID is opaque to it, and it
// shouldn't store it anywhere.
filtered_result->additional_properties.SetString(
filtered_result->additional_properties.SetStringWithoutPathExpansion(
onc::network_config::kGUID, service_path);
Append(filtered_result.release());
@@ -176,25 +179,56 @@ bool NetworkingPrivateGetPropertiesFunction::RunImpl() {
scoped_ptr<api::GetProperties::Params> params =
api::GetProperties::Params::Create(*args_);
EXTENSION_FUNCTION_VALIDATE(params);
// TODO(gspencer): Currently we're using the service path as the
// |network_guid|. Eventually this should be using the real GUID.
DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
dbus::ObjectPath(params->network_guid),
base::Bind(&NetworkingPrivateGetPropertiesFunction::ResultCallback,
this));
if (ManagedNetworkConfigurationHandler::IsInitialized()) {
ManagedNetworkConfigurationHandler::Get()->GetProperties(
params->network_guid,
base::Bind(
&NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess,
this),
base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed,
this));
} else {
// TODO(gspencer): Currently we're using the service path as the
// |network_guid|. Eventually this should be using the real GUID.
DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
dbus::ObjectPath(params->network_guid),
base::Bind(&NetworkingPrivateGetPropertiesFunction::ResultCallback,
this,
params->network_guid));
}
return true;
}
void NetworkingPrivateGetPropertiesFunction::ResultCallback(
const std::string& service_path,
DBusMethodCallStatus call_status,
const base::DictionaryValue& result) {
scoped_ptr<base::DictionaryValue> onc_properties(
onc::TranslateShillServiceToONCPart(
result,
&onc::kNetworkConfigurationSignature));
GetPropertiesSuccess(service_path,
*onc_properties);
}
void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess(
const std::string& service_path,
const base::DictionaryValue& dictionary) {
scoped_ptr<api::NetworkProperties> filtered_result(
CreateFilteredResult(result));
CreateFilteredResult(dictionary));
filtered_result->additional_properties.SetStringWithoutPathExpansion(
onc::network_config::kGUID, service_path);
results_ = api::GetProperties::Results::Create(*filtered_result);
SendResponse(true);
}
void NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed(
const std::string& error_name,
scoped_ptr<base::DictionaryValue> error_data) {
error_ = error_name;
SendResponse(false);
}
////////////////////////////////////////////////////////////////////////////////
// NetworkingPrivateGetVisibleNetworksFunction

@@ -30,8 +30,18 @@ class NetworkingPrivateGetPropertiesFunction : public AsyncExtensionFunction {
virtual bool RunImpl() OVERRIDE;
private:
void ResultCallback(chromeos::DBusMethodCallStatus call_status,
// Callback if talking to ShillServiceClient directly.
// TODO(pneubeck): Remove once the ManagedNetworkConfigurationHandler is
// stable.
void ResultCallback(const std::string& service_path,
chromeos::DBusMethodCallStatus call_status,
const base::DictionaryValue& result);
// Callbacks if talking to ManagedNetworkConfigurationHandler.
void GetPropertiesSuccess(const std::string& service_path,
const base::DictionaryValue& result);
void GetPropertiesFailed(const std::string& error_name,
scoped_ptr<base::DictionaryValue> error_data);
DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetPropertiesFunction);
};

@@ -0,0 +1,5 @@
per-file managed_network_configuration_handler.*=gspencer@chromium.org
per-file managed_network_configuration_handler.*=pneubeck@chromium.org
per-file onc_utils.*=gspencer@chromium.org
per-file onc_utils.*=pneubeck@chromium.org

@@ -0,0 +1,207 @@
// Copyright (c) 2013 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 "chrome/browser/chromeos/net/managed_network_configuration_handler.h"
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/guid.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
#include "chromeos/dbus/dbus_method_call_status.h"
#include "chromeos/dbus/dbus_thread_manager.h"
#include "chromeos/dbus/shill_manager_client.h"
#include "chromeos/dbus/shill_service_client.h"
#include "chromeos/network/network_configuration_handler.h"
#include "chromeos/network/network_event_log.h"
#include "chromeos/network/network_state.h"
#include "chromeos/network/network_state_handler.h"
#include "chromeos/network/onc/onc_constants.h"
#include "chromeos/network/onc/onc_signature.h"
#include "chromeos/network/onc/onc_translator.h"
#include "dbus/object_path.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
namespace chromeos {
namespace {
ManagedNetworkConfigurationHandler* g_configuration_handler_instance = NULL;
const char kLogModule[] = "ManagedNetworkConfigurationHandler";
// These are error strings used for error callbacks. None of these error
// messages are user-facing: they should only appear in logs.
const char kServicePath[] = "servicePath";
const char kSetOnUnconfiguredNetworkMessage[] =
"Unable to modify properties of an unconfigured network.";
const char kSetOnUnconfiguredNetwork[] = "Error.SetCalledOnUnconfiguredNetwork";
const char kUnknownServicePathMessage[] = "Service path is unknown.";
const char kUnknownServicePath[] = "Error.UnknownServicePath";
void RunErrorCallback(const std::string& service_path,
const std::string& error_name,
const std::string& error_message,
const network_handler::ErrorCallback& error_callback) {
network_event_log::AddEntry(kLogModule, error_name, error_message);
error_callback.Run(
error_name,
make_scoped_ptr(
network_handler::CreateErrorData(service_path,
error_name,
error_message)));
}
void TranslatePropertiesAndRunCallback(
const network_handler::DictionaryResultCallback& callback,
const std::string& service_path,
const base::DictionaryValue& shill_properties) {
scoped_ptr<base::DictionaryValue> onc_network(
onc::TranslateShillServiceToONCPart(
shill_properties,
&onc::kNetworkConfigurationSignature));
callback.Run(service_path, *onc_network);
}
} // namespace
// static
void ManagedNetworkConfigurationHandler::Initialize() {
CHECK(!g_configuration_handler_instance);
g_configuration_handler_instance = new ManagedNetworkConfigurationHandler;
}
// static
bool ManagedNetworkConfigurationHandler::IsInitialized() {
return g_configuration_handler_instance;
}
// static
void ManagedNetworkConfigurationHandler::Shutdown() {
CHECK(g_configuration_handler_instance);
delete g_configuration_handler_instance;
g_configuration_handler_instance = NULL;
}
// static
ManagedNetworkConfigurationHandler* ManagedNetworkConfigurationHandler::Get() {
CHECK(g_configuration_handler_instance);
return g_configuration_handler_instance;
}
void ManagedNetworkConfigurationHandler::GetProperties(
const std::string& service_path,
const network_handler::DictionaryResultCallback& callback,
const network_handler::ErrorCallback& error_callback) const {
// TODO(pneubeck): Merge with policies.
NetworkConfigurationHandler::Get()->GetProperties(
service_path,
base::Bind(&TranslatePropertiesAndRunCallback, callback),
error_callback);
}
void ManagedNetworkConfigurationHandler::SetProperties(
const std::string& service_path,
const base::DictionaryValue& properties,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const {
const NetworkState* state =
NetworkStateHandler::Get()->GetNetworkState(service_path);
if (!state) {
RunErrorCallback(service_path,
kUnknownServicePath,
kUnknownServicePathMessage,
error_callback);
}
std::string guid = state->guid();
if (guid.empty()) {
RunErrorCallback(service_path,
kSetOnUnconfiguredNetwork,
kSetOnUnconfiguredNetworkMessage,
error_callback);
}
// TODO(pneubeck): Enforce policies.
scoped_ptr<base::DictionaryValue> shill_dictionary(
onc::TranslateONCObjectToShill(
&onc::kNetworkConfigurationSignature,
properties));
NetworkConfigurationHandler::Get()->SetProperties(service_path,
*shill_dictionary,
callback,
error_callback);
}
void ManagedNetworkConfigurationHandler::Connect(
const std::string& service_path,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const {
// TODO(pneubeck): Update the user profile with tracked/followed settings of
// the shared profile.
NetworkConfigurationHandler::Get()->Connect(service_path,
callback,
error_callback);
}
void ManagedNetworkConfigurationHandler::Disconnect(
const std::string& service_path,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const {
NetworkConfigurationHandler::Get()->Disconnect(service_path,
callback,
error_callback);
}
void ManagedNetworkConfigurationHandler::CreateConfiguration(
const base::DictionaryValue& properties,
const network_handler::StringResultCallback& callback,
const network_handler::ErrorCallback& error_callback) const {
scoped_ptr<base::DictionaryValue> modified_properties(
properties.DeepCopy());
// If there isn't already a GUID attached to these properties, then
// generate one and add it.
std::string guid;
if (!properties.GetString(onc::network_config::kGUID, &guid)) {
guid = base::GenerateGUID();
modified_properties->SetStringWithoutPathExpansion(
onc::network_config::kGUID, guid);
} else {
NOTREACHED(); // TODO(pneubeck): Return an error using error_callback.
}
// TODO(pneubeck): Enforce policies.
scoped_ptr<base::DictionaryValue> shill_dictionary(
onc::TranslateONCObjectToShill(&onc::kNetworkConfigurationSignature,
properties));
NetworkConfigurationHandler::Get()->CreateConfiguration(*shill_dictionary,
callback,
error_callback);
}
void ManagedNetworkConfigurationHandler::RemoveConfiguration(
const std::string& service_path,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const {
NetworkConfigurationHandler::Get()->RemoveConfiguration(service_path,
callback,
error_callback);
}
ManagedNetworkConfigurationHandler::ManagedNetworkConfigurationHandler() {
}
ManagedNetworkConfigurationHandler::~ManagedNetworkConfigurationHandler() {
}
} // namespace chromeos

@@ -0,0 +1,121 @@
// Copyright (c) 2013 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.
#ifndef CHROME_BROWSER_CHROMEOS_NET_MANAGED_NETWORK_CONFIGURATION_HANDLER_H_
#define CHROME_BROWSER_CHROMEOS_NET_MANAGED_NETWORK_CONFIGURATION_HANDLER_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/gtest_prod_util.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/network/network_handler_callbacks.h"
namespace base {
class DictionaryValue;
}
namespace chromeos {
// The ManagedNetworkConfigurationHandler class is used to create and configure
// networks in ChromeOS using ONC.
//
// Its interface exposes only ONC and should decouple users from Shill.
// Internally it translates ONC to Shill dictionaries and calls through to the
// NetworkConfigurationHandler.
//
// For accessing lists of visible networks, and other state information, see the
// class NetworkStateHandler.
//
// This is a singleton and its lifetime is managed by the Chrome startup code.
//
// Network configurations are referred to by Shill's service path. These
// identifiers should at most be used to also access network state using the
// NetworkStateHandler, but dependencies to Shill should be avoided. In the
// future, we may switch to other identifiers.
//
// Note on callbacks: Because all the functions here are meant to be
// asynchronous, they all take a |callback| of some type, and an
// |error_callback|. When the operation succeeds, |callback| will be called, and
// when it doesn't, |error_callback| will be called with information about the
// error, including a symbolic name for the error and often some error message
// that is suitable for logging. None of the error message text is meant for
// user consumption.
//
// TODO(pneubeck): Enforce network policies.
class ManagedNetworkConfigurationHandler {
public:
// Initializes the singleton.
static void Initialize();
// Returns if the singleton is initialized.
static bool IsInitialized();
// Destroys the singleton.
static void Shutdown();
// Initialize() must be called before this.
static ManagedNetworkConfigurationHandler* Get();
// Provides the properties of the network with |service_path| to |callback|.
void GetProperties(
const std::string& service_path,
const network_handler::DictionaryResultCallback& callback,
const network_handler::ErrorCallback& error_callback) const;
// Sets the user's settings of an already configured network with
// |service_path|. A network can be initially configured by calling
// CreateConfiguration or if it is managed by a policy. The given properties
// will be merged with the existing settings, and it won't clear any existing
// properties.
void SetProperties(
const std::string& service_path,
const base::DictionaryValue& properties,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const;
// Initiates a connection with network that has |service_path|. |callback| is
// called if the connection request was successfully handled. That doesn't
// mean that the connection was successfully established.
void Connect(const std::string& service_path,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const;
// Initiates a disconnect with the network at |service_path|. |callback| is
// called if the diconnect request was successfully handled. That doesn't mean
// that the network is already diconnected.
void Disconnect(const std::string& service_path,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const;
// Initially configures an unconfigured network with the given user settings
// and returns the new identifier to |callback| if successful. Fails if the
// network was already configured by a call to this function or because of a
// policy.
void CreateConfiguration(
const base::DictionaryValue& properties,
const network_handler::StringResultCallback& callback,
const network_handler::ErrorCallback& error_callback) const;
// Removes the user's configuration from the network with |service_path|. The
// network may still show up in the visible networks after this, but no user
// configuration will remain. If it was managed, it will still be configured.
void RemoveConfiguration(
const std::string& service_path,
const base::Closure& callback,
const network_handler::ErrorCallback& error_callback) const;
private:
ManagedNetworkConfigurationHandler();
~ManagedNetworkConfigurationHandler();
DISALLOW_COPY_AND_ASSIGN(ManagedNetworkConfigurationHandler);
};
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_NET_MANAGED_NETWORK_CONFIGURATION_HANDLER_H_

@@ -522,6 +522,8 @@
'browser/chromeos/net/connectivity_state_helper.h',
'browser/chromeos/net/cros_network_change_notifier_factory.cc',
'browser/chromeos/net/cros_network_change_notifier_factory.h',
'browser/chromeos/net/managed_network_configuration_handler.cc',
'browser/chromeos/net/managed_network_configuration_handler.h',
'browser/chromeos/net/network_change_notifier_network_library.cc',
'browser/chromeos/net/network_change_notifier_network_library.h',
'browser/chromeos/net/network_portal_detector.cc',

@@ -24,6 +24,10 @@ const char kEnableNewNetworkChangeNotifier[] =
// Enables screensaver extensions.
const char kEnableScreensaverExtensions[] = "enable-screensaver-extensions";
// Enables the new NetworkConfigurationHandler class.
const char kEnableNewNetworkConfigurationHandlers[] =
"enable-new-network-configuration-handlers";
// Sends test messages on first call to RequestUpdate (stub only).
const char kSmsTestMessages[] = "sms-test-messages";

@@ -24,6 +24,7 @@ CHROMEOS_EXPORT extern const char kChromeOSReleaseBoard[];
CHROMEOS_EXPORT extern const char kDbusStub[];
CHROMEOS_EXPORT extern const char kEnableLocallyManagedUserUIExperiments[];
CHROMEOS_EXPORT extern const char kEnableNewNetworkChangeNotifier[];
CHROMEOS_EXPORT extern const char kEnableNewNetworkConfigurationHandlers[];
CHROMEOS_EXPORT extern const char kEnableScreensaverExtensions[];
CHROMEOS_EXPORT extern const char kSmsTestMessages[];

@@ -20,12 +20,12 @@
namespace chromeos {
static NetworkConfigurationHandler* g_network_configuration_handler = NULL;
namespace {
const char kLogModule[] = "NetworkConfigurationHandler";
NetworkConfigurationHandler* g_configuration_handler_instance = NULL;
// None of these error messages are user-facing: they should only appear in
// logs.
const char kErrorsListTag[] = "errors";
@@ -60,7 +60,7 @@ void ClearPropertiesCallback(
network_handler::CreateErrorData(service_path,
kClearPropertiesFailedError,
kClearPropertiesFailedErrorMessage));
LOG(ERROR) << "ClearPropertiesCallback Failed for service path: "
LOG(ERROR) << "ClearPropertiesCallback failed for service path: "
<< service_path;
error_data->Set("errors", result.DeepCopy());
scoped_ptr<base::ListValue> name_list(new base::ListValue);
@@ -85,7 +85,7 @@ void RunCallbackWithDictionaryValue(
network_handler::CreateErrorData(service_path,
kDBusFailedError,
kDBusFailedErrorMessage));
LOG(ERROR) << "CallbackWithDictionaryValue Failed for service path: "
LOG(ERROR) << "CallbackWithDictionaryValue failed for service path: "
<< service_path;
error_callback.Run(kDBusFailedError, error_data.Pass());
} else {
@@ -106,30 +106,24 @@ void IgnoreObjectPathCallback(const base::Closure& callback,
} // namespace
NetworkConfigurationHandler::NetworkConfigurationHandler() {
}
NetworkConfigurationHandler::~NetworkConfigurationHandler() {
}
// static
void NetworkConfigurationHandler::Initialize() {
CHECK(!g_network_configuration_handler);
g_network_configuration_handler = new NetworkConfigurationHandler();
CHECK(!g_configuration_handler_instance);
g_configuration_handler_instance = new NetworkConfigurationHandler;
}
// static
void NetworkConfigurationHandler::Shutdown() {
CHECK(g_network_configuration_handler);
delete g_network_configuration_handler;
g_network_configuration_handler = NULL;
CHECK(g_configuration_handler_instance);
delete g_configuration_handler_instance;
g_configuration_handler_instance = NULL;
}
// static
NetworkConfigurationHandler* NetworkConfigurationHandler::Get() {
CHECK(g_network_configuration_handler)
CHECK(g_configuration_handler_instance)
<< "NetworkConfigurationHandler::Get() called before Initialize()";
return g_network_configuration_handler;
return g_configuration_handler_instance;
}
void NetworkConfigurationHandler::GetProperties(
@@ -217,4 +211,10 @@ void NetworkConfigurationHandler::RemoveConfiguration(
kLogModule, service_path, error_callback));
}
NetworkConfigurationHandler::NetworkConfigurationHandler() {
}
NetworkConfigurationHandler::~NetworkConfigurationHandler() {
}
} // namespace chromeos

@@ -25,7 +25,8 @@ namespace chromeos {
// most calls are asynchronous for that reason. No calls will block on DBus
// calls.
//
// This is owned and it's lifetime managed by aura::Shell.
// This is owned and it's lifetime managed by the Chrome startup code. It's
// basically a singleton, but with explicit lifetime management.
//
// For accessing lists of remembered networks, and other state information, see
// the class NetworkStateHandler.
@@ -93,9 +94,8 @@ class CHROMEOS_EXPORT NetworkConfigurationHandler {
// Creates a network with the given properties in the active Shill profile,
// and returns the properties to |callback| if successful, along with the new
// service_path. See note on |callback| and |error_callback|, in class
// description above.
// and returns the new service_path to |callback| if successful. See note on
// |callback| and |error_callback|, in class description above.
void CreateConfiguration(
const base::DictionaryValue& properties,
const network_handler::StringResultCallback& callback,

@@ -88,12 +88,12 @@ class NetworkConfigurationHandlerTest : public testing::Test {
mock_dbus_thread_manager->mock_shill_service_client();
// Initialize DBusThreadManager with a stub implementation.
configuration_handler_.reset(new NetworkConfigurationHandler);
NetworkConfigurationHandler::Initialize();
message_loop_.RunUntilIdle();
}
virtual void TearDown() OVERRIDE {
configuration_handler_.reset();
NetworkConfigurationHandler::Shutdown();
DBusThreadManager::Shutdown();
}
@@ -159,7 +159,6 @@ class NetworkConfigurationHandlerTest : public testing::Test {
}
protected:
scoped_ptr<NetworkConfigurationHandler> configuration_handler_;
MockShillManagerClient* mock_manager_client_;
MockShillServiceClient* mock_service_client_;
MessageLoop message_loop_;
@@ -191,7 +190,7 @@ TEST_F(NetworkConfigurationHandlerTest, GetProperties) {
GetProperties(_, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnGetProperties));
configuration_handler_->GetProperties(
NetworkConfigurationHandler::Get()->GetProperties(
service_path,
base::Bind(&DictionaryValueCallback,
service_path,
@@ -214,7 +213,7 @@ TEST_F(NetworkConfigurationHandlerTest, SetProperties) {
ConfigureService(_, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnSetProperties));
configuration_handler_->SetProperties(
NetworkConfigurationHandler::Get()->SetProperties(
service_path,
value,
base::Bind(&base::DoNothing),
@@ -237,7 +236,7 @@ TEST_F(NetworkConfigurationHandlerTest, ClearProperties) {
ConfigureService(_, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnSetProperties));
configuration_handler_->SetProperties(
NetworkConfigurationHandler::Get()->SetProperties(
service_path,
value,
base::Bind(&base::DoNothing),
@@ -251,7 +250,7 @@ TEST_F(NetworkConfigurationHandlerTest, ClearProperties) {
ClearProperties(_, _, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnClearProperties));
configuration_handler_->ClearProperties(
NetworkConfigurationHandler::Get()->ClearProperties(
service_path,
values_to_clear,
base::Bind(&base::DoNothing),
@@ -274,7 +273,7 @@ TEST_F(NetworkConfigurationHandlerTest, ClearPropertiesError) {
ConfigureService(_, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnSetProperties));
configuration_handler_->SetProperties(
NetworkConfigurationHandler::Get()->SetProperties(
service_path,
value,
base::Bind(&base::DoNothing),
@@ -289,7 +288,7 @@ TEST_F(NetworkConfigurationHandlerTest, ClearPropertiesError) {
ClearProperties(_, _, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnClearPropertiesError));
configuration_handler_->ClearProperties(
NetworkConfigurationHandler::Get()->ClearProperties(
service_path,
values_to_clear,
base::Bind(&base::DoNothing),
@@ -304,7 +303,7 @@ TEST_F(NetworkConfigurationHandlerTest, Connect) {
Connect(_, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnConnect));
configuration_handler_->Connect(
NetworkConfigurationHandler::Get()->Connect(
service_path,
base::Bind(&base::DoNothing),
base::Bind(&ErrorCallback, false, service_path));
@@ -318,7 +317,7 @@ TEST_F(NetworkConfigurationHandlerTest, Disconnect) {
Disconnect(_, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnDisconnect));
configuration_handler_->Disconnect(
NetworkConfigurationHandler::Get()->Disconnect(
service_path,
base::Bind(&base::DoNothing),
base::Bind(&ErrorCallback, false, service_path));
@@ -339,7 +338,7 @@ TEST_F(NetworkConfigurationHandlerTest, CreateConfiguration) {
GetService(_, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnGetService));
configuration_handler_->CreateConfiguration(
NetworkConfigurationHandler::Get()->CreateConfiguration(
value,
base::Bind(&StringResultCallback, std::string("/service/2")),
base::Bind(&ErrorCallback, false, std::string("")));
@@ -354,7 +353,7 @@ TEST_F(NetworkConfigurationHandlerTest, RemoveConfiguration) {
Remove(_, _, _)).WillOnce(
Invoke(this,
&NetworkConfigurationHandlerTest::OnRemove));
configuration_handler_->RemoveConfiguration(
NetworkConfigurationHandler::Get()->RemoveConfiguration(
service_path,
base::Bind(&base::DoNothing),
base::Bind(&ErrorCallback, false, service_path));

@@ -9,6 +9,7 @@
#include "base/basictypes.h"
#include "base/callback.h"
#include "chromeos/chromeos_export.h"
namespace base {
class DictionaryValue;
@@ -31,9 +32,10 @@ typedef base::Callback<
void(const std::string& service_path)> StringResultCallback;
// Create a DictionaryValue for passing to ErrorCallback
base::DictionaryValue* CreateErrorData(const std::string& service_path,
const std::string& error_name,
const std::string& error_message);
CHROMEOS_EXPORT base::DictionaryValue* CreateErrorData(
const std::string& service_path,
const std::string& error_name,
const std::string& error_message);
// Callback for Shill errors. |path| may be blank if not relevant.
// Logs an error and calls |error_callback| if not null.

@@ -37,6 +37,8 @@ bool NetworkState::PropertyChanged(const std::string& key,
return GetStringValue(key, value, &technology_);
} else if (key == flimflam::kDeviceProperty) {
return GetStringValue(key, value, &device_path_);
} else if (key == flimflam::kGuidProperty) {
return GetStringValue(key, value, &guid_);
}
return false;
}

@@ -25,14 +25,17 @@ class CHROMEOS_EXPORT NetworkState : public ManagedState {
// Accessors
const std::string& security() const { return security_; }
const std::string& technology() const { return technology_; }
const std::string& ip_address() const { return ip_address_; }
const std::string& device_path() const { return device_path_; }
const std::string& guid() const { return guid_; }
const std::string& connection_state() const { return connection_state_; }
const std::string& error() const { return error_; }
// Wireless property accessors
int signal_strength() const { return signal_strength_; }
// Cellular property accessors
const std::string& technology() const { return technology_; }
const std::string& activation_state() const { return activation_state_; }
const std::string& roaming() const { return roaming_; }
int signal_strength() const { return signal_strength_; }
bool IsConnectedState() const;
bool IsConnectingState() const;
@@ -53,6 +56,7 @@ class CHROMEOS_EXPORT NetworkState : public ManagedState {
// Common Network Service properties
std::string security_;
std::string device_path_;
std::string guid_;
std::string ip_address_;
std::string connection_state_;
std::string error_;