#include "base/logging.h"
#include "base/prefs/pref_service.h"
#include "base/values.h"
-#include "chrome/browser/chromeos/login/user.h"
-#include "chrome/browser/chromeos/login/user_manager.h"
#include "chrome/browser/chromeos/ui_proxy_config.h"
#include "chrome/browser/prefs/proxy_config_dictionary.h"
#include "chrome/common/pref_names.h"
-#include "chromeos/network/favorite_state.h"
#include "chromeos/network/managed_network_configuration_handler.h"
#include "chromeos/network/network_configuration_handler.h"
#include "chromeos/network/network_handler.h"
#include "chromeos/network/onc/onc_signature.h"
#include "chromeos/network/onc/onc_translator.h"
#include "chromeos/network/onc/onc_utils.h"
+#include "components/user_manager/user.h"
+#include "components/user_manager/user_manager.h"
#include "net/base/host_port_pair.h"
#include "net/proxy/proxy_bypass_rules.h"
#include "net/proxy/proxy_server.h"
// user attribute.
class UserStringSubstitution : public chromeos::onc::StringSubstitution {
public:
- explicit UserStringSubstitution(const chromeos::User* user) : user_(user) {}
+ explicit UserStringSubstitution(const user_manager::User* user)
+ : user_(user) {}
virtual ~UserStringSubstitution() {}
virtual bool GetSubstitute(const std::string& placeholder,
}
private:
- const chromeos::User* user_;
+ const user_manager::User* user_;
DISALLOW_COPY_AND_ASSIGN(UserStringSubstitution);
};
} // namespace
void ExpandStringPlaceholdersInNetworksForUser(
- const chromeos::User* user,
+ const user_manager::User* user,
base::ListValue* network_configs) {
if (!user) {
// In tests no user may be logged in. It's not harmful if we just don't
chromeos::onc::ExpandStringsInNetworks(substitution, network_configs);
}
-void ImportNetworksForUser(const chromeos::User* user,
+void ImportNetworksForUser(const user_manager::User* user,
const base::ListValue& network_configs,
std::string* error) {
error->clear();
onc::TranslateONCObjectToShill(&onc::kNetworkConfigurationSignature,
*normalized_network);
- scoped_ptr<NetworkUIData> ui_data = NetworkUIData::CreateFromONC(
- ::onc::ONC_SOURCE_USER_IMPORT, *normalized_network);
+ scoped_ptr<NetworkUIData> ui_data(
+ NetworkUIData::CreateFromONC(::onc::ONC_SOURCE_USER_IMPORT));
base::DictionaryValue ui_data_dict;
ui_data->FillDictionary(&ui_data_dict);
std::string ui_data_json;
const base::DictionaryValue* FindPolicyForActiveUser(
const std::string& guid,
::onc::ONCSource* onc_source) {
- const User* user = UserManager::Get()->GetActiveUser();
+ const user_manager::User* user =
+ user_manager::UserManager::Get()->GetActiveUser();
std::string username_hash = user ? user->username_hash() : std::string();
return NetworkHandler::Get()->managed_network_configuration_handler()->
FindPolicyByGUID(username_hash, guid, onc_source);
const base::DictionaryValue* GetGlobalConfigFromPolicy(bool for_active_user) {
std::string username_hash;
if (for_active_user) {
- const User* user = UserManager::Get()->GetActiveUser();
+ const user_manager::User* user =
+ user_manager::UserManager::Get()->GetActiveUser();
if (!user) {
LOG(ERROR) << "No user logged in yet.";
return NULL;
std::string auth;
ethernet->GetStringWithoutPathExpansion(::onc::ethernet::kAuthentication,
&auth);
- if (auth == ::onc::ethernet::kNone)
+ if (auth == ::onc::ethernet::kAuthenticationNone)
return network;
}
return NULL;
const base::DictionaryValue* GetNetworkConfigForNetworkFromOnc(
const base::ListValue& network_configs,
- const FavoriteState& favorite) {
+ const NetworkState& network) {
// In all cases except Ethernet, we use the GUID of |network|.
- if (!favorite.Matches(NetworkTypePattern::Ethernet()))
- return GetNetworkConfigByGUID(network_configs, favorite.guid());
+ if (!network.Matches(NetworkTypePattern::Ethernet()))
+ return GetNetworkConfigByGUID(network_configs, network.guid());
// Ethernet is always shared and thus cannot store a GUID per user. Thus we
// search for any Ethernet policy intead of a matching GUID.
// the respective ONC policy. The EthernetEAP service itself is however never
// in state "connected". An EthernetEAP policy must be applied, if an Ethernet
// service is connected using the EAP parameters.
- const FavoriteState* ethernet_eap = NULL;
+ const NetworkState* ethernet_eap = NULL;
if (NetworkHandler::IsInitialized()) {
ethernet_eap =
NetworkHandler::Get()->network_state_handler()->GetEAPForEthernet(
- favorite.path());
+ network.path());
}
// The GUID associated with the EthernetEAP service refers to the ONC policy
const base::DictionaryValue* GetPolicyForNetworkFromPref(
const PrefService* pref_service,
const char* pref_name,
- const FavoriteState& favorite) {
+ const NetworkState& network) {
if (!pref_service) {
VLOG(2) << "No pref service";
return NULL;
onc_policy_value->GetAsList(&onc_policy);
DCHECK(onc_policy);
- return GetNetworkConfigForNetworkFromOnc(*onc_policy, favorite);
+ return GetNetworkConfigForNetworkFromOnc(*onc_policy, network);
}
} // namespace
-const base::DictionaryValue* GetPolicyForFavoriteNetwork(
+const base::DictionaryValue* GetPolicyForNetwork(
const PrefService* profile_prefs,
const PrefService* local_state_prefs,
- const FavoriteState& favorite,
+ const NetworkState& network,
::onc::ONCSource* onc_source) {
- VLOG(2) << "GetPolicyForFavoriteNetwork: " << favorite.path();
+ VLOG(2) << "GetPolicyForNetwork: " << network.path();
*onc_source = ::onc::ONC_SOURCE_NONE;
const base::DictionaryValue* network_policy = GetPolicyForNetworkFromPref(
- profile_prefs, prefs::kOpenNetworkConfiguration, favorite);
+ profile_prefs, prefs::kOpenNetworkConfiguration, network);
if (network_policy) {
- VLOG(1) << "Network " << favorite.path() << " is managed by user policy.";
+ VLOG(1) << "Network " << network.path() << " is managed by user policy.";
*onc_source = ::onc::ONC_SOURCE_USER_POLICY;
return network_policy;
}
network_policy = GetPolicyForNetworkFromPref(
- local_state_prefs, prefs::kDeviceOpenNetworkConfiguration, favorite);
+ local_state_prefs, prefs::kDeviceOpenNetworkConfiguration, network);
if (network_policy) {
- VLOG(1) << "Network " << favorite.path() << " is managed by device policy.";
+ VLOG(1) << "Network " << network.path() << " is managed by device policy.";
*onc_source = ::onc::ONC_SOURCE_DEVICE_POLICY;
return network_policy;
}
- VLOG(2) << "Network " << favorite.path() << " is unmanaged.";
+ VLOG(2) << "Network " << network.path() << " is unmanaged.";
return NULL;
}
-bool HasPolicyForFavoriteNetwork(const PrefService* profile_prefs,
- const PrefService* local_state_prefs,
- const FavoriteState& network) {
+bool HasPolicyForNetwork(const PrefService* profile_prefs,
+ const PrefService* local_state_prefs,
+ const NetworkState& network) {
::onc::ONCSource ignored_onc_source;
- const base::DictionaryValue* policy = onc::GetPolicyForFavoriteNetwork(
+ const base::DictionaryValue* policy = onc::GetPolicyForNetwork(
profile_prefs, local_state_prefs, network, &ignored_onc_source);
return policy != NULL;
}
projects / platform / framework / web / crosswalk.git / blobdiff