| // 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. |
| |
| #ifndef CHROMEOS_ASH_COMPONENTS_NETWORK_NETWORK_STATE_HANDLER_H_ |
| #define CHROMEOS_ASH_COMPONENTS_NETWORK_NETWORK_STATE_HANDLER_H_ |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "base/callback_forward.h" |
| #include "base/component_export.h" |
| #include "base/gtest_prod_util.h" |
| #include "base/observer_list.h" |
| #include "base/sequence_checker.h" |
| #include "chromeos/ash/components/network/managed_state.h" |
| #include "chromeos/ash/components/network/network_handler.h" |
| #include "chromeos/ash/components/network/network_handler_callbacks.h" |
| #include "chromeos/ash/components/network/network_state.h" |
| #include "chromeos/ash/components/network/network_type_pattern.h" |
| #include "chromeos/ash/components/network/shill_property_handler.h" |
| |
| namespace base { |
| class Location; |
| class Value; |
| } // namespace base |
| |
| namespace ash { |
| |
| class DeviceState; |
| class NetworkStateHandlerObserver; |
| class NetworkStateHandlerTest; |
| |
| // Class for tracking the list of visible networks and their properties. |
| // |
| // This class maps essential properties from the connection manager (Shill) for |
| // each visible network. It is not used to change the properties of services or |
| // devices, only global (manager) properties. |
| // |
| // All getters return the currently cached properties. This class is expected to |
| // keep properties up to date by managing the appropriate Shill observers. |
| // It will invoke its own more specific observer methods when the specified |
| // changes occur. |
| // |
| // Some notes about NetworkState and GUIDs: |
| // * A NetworkState exists for all network services stored in a profile, and |
| // all "visible" networks (physically connected networks like ethernet and |
| // cellular or in-range wifi networks). If the network is stored in a profile, |
| // NetworkState.IsInProfile() will return true. |
| // * "Visible" networks return true for NetworkState.visible(). |
| // * All networks saved to a profile will have a saved GUID that is persistent |
| // across sessions. |
| // * Networks that are not saved to a profile will have a GUID assigned when |
| // the initial properties are received. The GUID will be consistent for |
| // the duration of a session, even if the network drops out and returns. |
| |
| class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkStateHandler |
| : public internal::ShillPropertyHandler::Listener { |
| public: |
| typedef std::vector<std::unique_ptr<ManagedState>> ManagedStateList; |
| typedef std::vector<const NetworkState*> NetworkStateList; |
| typedef std::vector<const DeviceState*> DeviceStateList; |
| |
| class TetherSortDelegate { |
| public: |
| // Sorts |tether_networks| according to the Tether component rules. |
| // |tether_networks| contains only networks of type Tether. |
| virtual void SortTetherNetworkList( |
| ManagedStateList* tether_networks) const = 0; |
| }; |
| |
| // Cellular networks may not have an associated Shill Service (e.g. when the |
| // SIM is locked, a mobile network is not available or Shill is not able to |
| // see eSIM profiles through MM). StubCellularNetworksProvider adds stub |
| // cellular networks if necessary and removes previously created stub networks |
| // that are no longer required. If a StubCellularNetworksProvider instance is |
| // set, then |AddOrRemoveStubCellularNetworks| is called before sorting |
| // networks list. |
| class StubCellularNetworksProvider { |
| public: |
| virtual ~StubCellularNetworksProvider() = default; |
| |
| // Checks |network_list| to add or remove stub cellular networks. New |
| // stub networks will be addeded to |new_stub_networks| list. Stub networks |
| // that are not required anymore are removed from |network_list|. Returns |
| // true if networks were removed from |network_list| or |new_stub_networks| |
| // is non empty. |
| virtual bool AddOrRemoveStubCellularNetworks( |
| ManagedStateList& network_list, |
| ManagedStateList& new_stub_networks, |
| const DeviceState* device) = 0; |
| |
| // Provides metadata associated with a stub network with the given ICCID. |
| // If |iccid| corresponds to an installed eSIM profile or SIM card, true is |
| // returned and the "out" parameters are set. Otherwise, false is returned |
| // and the values are not set. |
| virtual bool GetStubNetworkMetadata(const std::string& iccid, |
| const DeviceState* cellular_device, |
| std::string* service_path_out, |
| std::string* guid_out) = 0; |
| }; |
| |
| enum TechnologyState { |
| TECHNOLOGY_UNAVAILABLE, |
| TECHNOLOGY_AVAILABLE, |
| TECHNOLOGY_UNINITIALIZED, |
| TECHNOLOGY_ENABLING, |
| TECHNOLOGY_ENABLED, |
| TECHNOLOGY_DISABLING, |
| TECHNOLOGY_PROHIBITED |
| }; |
| |
| NetworkStateHandler(const NetworkStateHandler&) = delete; |
| NetworkStateHandler& operator=(const NetworkStateHandler&) = delete; |
| |
| ~NetworkStateHandler() override; |
| |
| // Called just before destruction to give observers a chance to remove |
| // themselves and disable any networking. |
| void Shutdown(); |
| |
| // Add/remove observers. |
| void AddObserver(NetworkStateHandlerObserver* observer, |
| const base::Location& from_here); |
| void AddObserver(NetworkStateHandlerObserver* observer); |
| |
| void RemoveObserver(NetworkStateHandlerObserver* observer, |
| const base::Location& from_here); |
| void RemoveObserver(NetworkStateHandlerObserver* observer); |
| |
| bool HasObserver(NetworkStateHandlerObserver* observer); |
| |
| // Returns the state for technology |type|. Only |
| // NetworkTypePattern::Primitive, ::Mobile, ::Ethernet, and ::Tether are |
| // supported. |
| TechnologyState GetTechnologyState(const NetworkTypePattern& type) const; |
| bool IsTechnologyAvailable(const NetworkTypePattern& type) const { |
| return GetTechnologyState(type) != TECHNOLOGY_UNAVAILABLE; |
| } |
| bool IsTechnologyEnabled(const NetworkTypePattern& type) const { |
| return GetTechnologyState(type) == TECHNOLOGY_ENABLED; |
| } |
| bool IsTechnologyProhibited(const NetworkTypePattern& type) const { |
| return GetTechnologyState(type) == TECHNOLOGY_PROHIBITED; |
| } |
| bool IsTechnologyUninitialized(const NetworkTypePattern& type) const { |
| return GetTechnologyState(type) == TECHNOLOGY_UNINITIALIZED; |
| } |
| |
| // Asynchronously sets the technology enabled property for |type|. Only |
| // NetworkTypePattern::Primitive, ::Mobile and ::Ethernet are supported. |
| // Note: Modifies Manager state. Calls |error_callback| on failure. |
| void SetTechnologyEnabled(const NetworkTypePattern& type, |
| bool enabled, |
| network_handler::ErrorCallback error_callback); |
| |
| // Sets the Tether technology state. Because Tether networks do not represent |
| // real Shill networks, this value must be set by the Tether component rather |
| // than being generated by Shill. See TetherDeviceStateManager for more |
| // details. |
| void SetTetherTechnologyState(TechnologyState technology_state); |
| |
| // Sets the scanning state of the Tether technology. Since Tether network |
| // scans are not actually performed as part of Shill, this value must be set |
| // by the Tether component. |
| void SetTetherScanState(bool is_scanning); |
| |
| // Asynchronously sets the list of prohibited technologies. The accepted |
| // values are the shill network technology identifiers. See also |
| // chromeos::onc::Validator::ValidateGlobalNetworkConfiguration(). |
| void SetProhibitedTechnologies( |
| const std::vector<std::string>& prohibited_technologies); |
| |
| // Finds and returns a device state by |device_path| or NULL if not found. |
| const DeviceState* GetDeviceState(const std::string& device_path) const; |
| |
| // Finds and returns a device state by |type|. Returns NULL if not found. |
| const DeviceState* GetDeviceStateByType(const NetworkTypePattern& type) const; |
| |
| // Returns true if any device of |type| is scanning. |
| bool GetScanningByType(const NetworkTypePattern& type) const; |
| |
| // Finds and returns a network state by |service_path| or NULL if not found. |
| // Note: NetworkState is frequently updated asynchronously, i.e. properties |
| // are not always updated all at once. This will contain the most recent |
| // value for each property. To receive notifications when a property changes, |
| // observe this class and implement NetworkPropertyChanged(). |
| const NetworkState* GetNetworkState(const std::string& service_path) const; |
| |
| // Returns the default network (which includes VPNs) based on the Shill |
| // Manager.DefaultNetwork property. Normally this is the same as |
| // ConnectedNetworkByType(NetworkTypePattern::Default()), but the timing might |
| // differ. |
| const NetworkState* DefaultNetwork() const; |
| |
| // Returns the primary connected network matching |type|, otherwise null. |
| const NetworkState* ConnectedNetworkByType(const NetworkTypePattern& type); |
| |
| // Returns the primary connecting network matching |type|, otherwise null. |
| const NetworkState* ConnectingNetworkByType(const NetworkTypePattern& type); |
| |
| // Returns the primary active network of matching |type|, otherwise null. |
| // See also GetActiveNetworkListByType. |
| const NetworkState* ActiveNetworkByType(const NetworkTypePattern& type); |
| |
| // Like ConnectedNetworkByType() but returns any matching visible network or |
| // NULL. Mostly useful for mobile networks where there is generally only one |
| // network. Note: O(N). |
| const NetworkState* FirstNetworkByType(const NetworkTypePattern& type); |
| |
| // Sets the |connect_requested_| property of a NetworkState for |
| // |service_path| if it exists. This is used to inform the UI that a network |
| // is connecting before the state is set in Shill. If |connect_requested| is |
| // true, NetworkState::IsConnectingState() will return true. This will cause |
| // the network to be sorted first and it will be part of the active list. |
| // Also clears shill_connect_error_ for the NetworkState. |
| void SetNetworkConnectRequested(const std::string& service_path, |
| bool connect_requested); |
| |
| // Calls NetworkState::set_shill_connect_error_ for |service_path|. |
| void SetShillConnectError(const std::string& service_path, |
| const std::string& shill_connect_error); |
| |
| // Called from Chrome's network portal detector when Chrome has detected |
| // that a network is in a captive portal state. |
| void SetNetworkChromePortalState(const std::string& service_path, |
| NetworkState::PortalState portal_state); |
| |
| // Returns the aa:bb formatted hardware (MAC) address for the first connected |
| // network matching |type|, or an empty string if none is connected. |
| std::string FormattedHardwareAddressForType(const NetworkTypePattern& type); |
| |
| // Convenience method to call GetNetworkListByType(visible=true). |
| void GetVisibleNetworkListByType(const NetworkTypePattern& type, |
| NetworkStateList* list); |
| |
| // Convenience method for GetVisibleNetworkListByType(Default). |
| void GetVisibleNetworkList(NetworkStateList* list); |
| |
| // Sets |list| to contain the list of networks with matching |type| and the |
| // following properties: |
| // |configured_only| - if true only include networks where IsInProfile is true |
| // |visible_only| - if true only include networks in the visible Services list |
| // |limit| - if > 0 limits the number of results. |
| // The returned list contains a copy of NetworkState pointers which should not |
| // be stored or used beyond the scope of the calling function (i.e. they may |
| // later become invalid, but only on the UI thread). SortNetworkList() will be |
| // called if necessary to provide the states in a convenient order (see |
| // SortNetworkList for details). |
| void GetNetworkListByType(const NetworkTypePattern& type, |
| bool configured_only, |
| bool visible_only, |
| size_t limit, |
| NetworkStateList* list); |
| |
| // Sets |list| to contain the active networks matching |type|. An 'active' |
| // network is connecting or connected, and the first connected active network |
| // is the primary or 'default' network providing connectivity (which may be a |
| // VPN, use NetworkTypePattern::NonVirtual() to ignore VPNs). See |
| // GetNetworkListByType for notes on |list| results. |
| void GetActiveNetworkListByType(const NetworkTypePattern& type, |
| NetworkStateList* list); |
| |
| // Finds and returns the NetworkState associated with |service_path| or NULL |
| // if not found. If |configured_only| is true, only returns saved entries |
| // (IsInProfile is true). |
| const NetworkState* GetNetworkStateFromServicePath( |
| const std::string& service_path, |
| bool configured_only) const; |
| |
| // Finds and returns the NetworkState associated with |guid| or NULL if not |
| // found. This returns all entries (IsInProfile() may be true or false). |
| const NetworkState* GetNetworkStateFromGuid(const std::string& guid) const; |
| |
| // Creates a Tether NetworkState that has no underlying shill type or |
| // service. When initially created, it does not actually represent a real |
| // network. The |guid| provided must be non-empty. If a network with |guid| |
| // already exists, this method will do nothing. Use the provided |guid| to |
| // refer to and fetch this NetworkState in the future. Note that the |
| // |has_connected_to_host| parameter refers to whether the current device has |
| // already connected to the Tether host device providing this Tether network |
| // in the past. |
| void AddTetherNetworkState(const std::string& guid, |
| const std::string& name, |
| const std::string& carrier, |
| int battery_percentage, |
| int signal_strength, |
| bool has_connected_to_host); |
| |
| // Updates the Tether properties (carrier, battery percentage, and signal |
| // strength) for a network which has already been added via |
| // AddTetherNetworkState. Returns whether the update was successful. |
| bool UpdateTetherNetworkProperties(const std::string& guid, |
| const std::string& carrier, |
| int battery_percentage, |
| int signal_strength); |
| |
| // Updates whether the Tether network with GUID |guid| has connected to the |
| // host device before, setting the value to true. Note that there is no way to |
| // change this value back to false. If no network with GUID |guid| is |
| // registered or if the network is registered and its HasConnectedToHost value |
| // was already true, this function does nothing. Returns whether the value was |
| // actually changed. |
| bool SetTetherNetworkHasConnectedToHost(const std::string& guid); |
| |
| // Remove a Tether NetworkState, using the same |guid| passed to |
| // AddTetherNetworkState(). If no network with GUID |guid| is registered, this |
| // function does nothing. Returns whether the network was actually removed. |
| bool RemoveTetherNetworkState(const std::string& guid); |
| |
| // Disassociates the Tether network specified by |tether_network_guid| from |
| // its associated Wi-Fi network. Returns whether the networkd were |
| // successfully disassociated. |
| bool DisassociateTetherNetworkStateFromWifiNetwork( |
| const std::string& tether_network_guid); |
| |
| // Inform NetworkStateHandler that the provided Tether network with the |
| // provided guid |tether_network_guid| is associated with the Wi-Fi network |
| // with the provided guid |wifi_network_guid|. This Wi-Fi network can now be |
| // hidden in the UI, and the Tether network will act as its proxy. Returns |
| // false if the association failed (e.g., one or both networks don't exist). |
| bool AssociateTetherNetworkStateWithWifiNetwork( |
| const std::string& tether_network_guid, |
| const std::string& wifi_network_guid); |
| |
| // Set the connection_state of the Tether NetworkState corresponding to the |
| // provided |guid| to "Disconnected". This will be reflected in the UI. |
| void SetTetherNetworkStateDisconnected(const std::string& guid); |
| |
| // Set the connection_state of the Tether NetworkState corresponding to the |
| // provided |guid| to "Connecting". This will be reflected in the UI. |
| void SetTetherNetworkStateConnecting(const std::string& guid); |
| |
| // Set the connection_state of the Tether NetworkState corresponding to the |
| // provided |guid| to "Connected". This will be reflected in the UI. |
| void SetTetherNetworkStateConnected(const std::string& guid); |
| |
| void set_tether_sort_delegate( |
| const TetherSortDelegate* tether_sort_delegate) { |
| tether_sort_delegate_ = tether_sort_delegate; |
| } |
| |
| // Sets |list| to contain the list of devices. The returned list contains |
| // a copy of DeviceState pointers which should not be stored or used beyond |
| // the scope of the calling function (i.e. they may later become invalid, but |
| // only on the UI thread). |
| void GetDeviceList(DeviceStateList* list) const; |
| |
| // Like GetDeviceList() but only returns networks with matching |type|. |
| void GetDeviceListByType(const NetworkTypePattern& type, |
| DeviceStateList* list) const; |
| |
| // Requests a network scan. This may trigger updates to the network |
| // list, which will trigger the appropriate observer calls. |
| // Note: If |type| is Cellular, a mobile network scan will be requested |
| // if supported. This is disruptive and should only be triggered by an |
| // explicit user action. |
| void RequestScan(const NetworkTypePattern& type); |
| |
| // Requests an update for an existing NetworkState, e.g. after configuring |
| // a network. This is a no-op if an update request is already pending. To |
| // ensure that a change is picked up, this must be called after Shill |
| // acknowledged it (e.g. in the callback of a SetProperties). |
| // When the properties are received, NetworkPropertiesUpdated will be |
| // signaled for each member of |observers_|, regardless of whether any |
| // properties actually changed. Note that this is a no-op for Tether networks. |
| void RequestUpdateForNetwork(const std::string& service_path); |
| |
| // Informs NetworkStateHandler to notify observers that the properties for |
| // the network may have changed. Called e.g. when the proxy properties may |
| // have changed. |
| void SendUpdateNotificationForNetwork(const std::string& service_path); |
| |
| // Clears the last_error value for the NetworkState for |service_path|. |
| void ClearLastErrorForNetwork(const std::string& service_path); |
| |
| // Sets the list of devices on which portal check is enabled. |
| void SetCheckPortalList(const std::string& check_portal_list); |
| |
| // Sets the Manager.WakeOnLan property. Note: we do not track this state, we |
| // only set it. |
| void SetWakeOnLanEnabled(bool enabled); |
| |
| // Sets the DHCP HostName property. Note: This does not directly set |
| // |hostname_|, it sets the Shill property and relies on Shill emitting the |
| // change which updates the cached |hostname_|. This ensures that Chrome and |
| // Shill are in sync. |
| void SetHostname(const std::string& hostname); |
| |
| // Returns the cached DHCP HostName property provided by Shill. Initialized |
| // to an empty string and set once the Manager properties are received. |
| const std::string& hostname() const { return hostname_; } |
| |
| // Enable or disable network bandwidth throttling, on all interfaces on the |
| // system. If |enabled| is true, |upload_rate_kbits| and |download_rate_kbits| |
| // are the desired rates (in kbits/s) to throttle to. If |enabled| is false, |
| // throttling is off, and the rates are ignored. |
| void SetNetworkThrottlingStatus(bool enabled, |
| uint32_t upload_rate_kbits, |
| uint32_t download_rate_kbits); |
| |
| // Sets the Fast Transition property. 802.11r Fast BSS Transition allows |
| // wireless Access Points to share information before a device initiates a |
| // reassociation. This allows devices to roam much more quickly. |
| void SetFastTransitionStatus(bool enabled); |
| |
| const std::string& GetCheckPortalListForTest() const { |
| return check_portal_list_; |
| } |
| |
| // Returns the NetworkState for the EthernetEAP service, which contains the |
| // EAP parameters used by the Ethernet network matching |service_path|, if it |
| // exists. If |connected_only| is true, only returns the EthernetEAP state |
| // if the Ethernet network is connected using EAP. Otherwise returns null. |
| const NetworkState* GetEAPForEthernet(const std::string& service_path, |
| bool connected_only); |
| |
| // Sets the |error_| property of the matching NetworkState for tests. |
| void SetErrorForTest(const std::string& service_path, |
| const std::string& error); |
| |
| void SetDeviceStateUpdatedForTest(const std::string& device_path); |
| |
| // Sets |allow_only_policy_wifi_networks_to_connect_|, |
| // |allow_only_policy_wifi_networks_to_connect_if_available_| and |
| // |blocked_hex_ssids_| and calls |
| // |UpdateBlockedNetworksInternal(NetworkTypePattern::Wifi())|. |
| virtual void UpdateBlockedWifiNetworks( |
| bool only_managed, |
| bool available_only, |
| const std::vector<std::string>& blocked_hex_ssids); |
| |
| // Sets |allow_only_policy_cellular_networks_to_connect_| and |
| // calls |UpdateBlockedNetworksInternal(NetworkTypePattern::Cellular())| |
| virtual void UpdateBlockedCellularNetworks(bool only_managed); |
| |
| // Returns the NetworkState associated to the wifi device's |
| // available_managed_network_path or |nullptr| if no managed network is |
| // available. |
| const NetworkState* GetAvailableManagedWifiNetwork() const; |
| |
| // Returns true if a user is logged in and the networks for the logged in user |
| // have been loaded. |
| bool IsProfileNetworksLoaded(); |
| |
| // Returns true if the AllowOnlyPolicyNetworksToConnect policy is enabled or |
| // if the AllowOnlyPolicyNetworksToConnectIfAvailable policy is enabled and |
| // there is a managed wifi network available. |
| bool OnlyManagedWifiNetworksAllowed() const; |
| |
| // Calls AddOrRemoveStubCellularNetworks on CellularStubServiceProvider if |
| // set, sorts network list and notifies network list change if required. |
| void SyncStubCellularNetworks(); |
| |
| // Requests traffic counters for a service denoted by |service_path|. |
| void RequestTrafficCounters(const std::string& service_path, |
| DBusMethodCallback<base::Value>); |
| |
| // Resets traffic counters for a service denoted by |service_path|. |
| void ResetTrafficCounters(const std::string& service_path); |
| |
| bool default_network_is_metered() const { |
| return default_network_is_metered_; |
| } |
| |
| void set_stub_cellular_networks_provider( |
| StubCellularNetworksProvider* stub_cellular_networks_provider) { |
| stub_cellular_networks_provider_ = stub_cellular_networks_provider; |
| } |
| |
| // Constructs and initializes an instance for testing. |
| static std::unique_ptr<NetworkStateHandler> InitializeForTest(); |
| |
| // Default set of comma separated interfaces on which to enable |
| // portal checking. |
| static const char kDefaultCheckPortalList[]; |
| |
| protected: |
| friend class NetworkHandler; |
| NetworkStateHandler(); |
| |
| // ShillPropertyHandler::Listener overrides. |
| |
| // This adds new entries to |network_list_| or |device_list_| and deletes any |
| // entries that are no longer in the list. |
| void UpdateManagedList(ManagedState::ManagedType type, |
| const base::Value& entries) override; |
| |
| // The list of profiles changed (i.e. a user has logged in). Re-request |
| // properties for all services since they may have changed. |
| void ProfileListChanged(const base::Value& profile_list) override; |
| |
| // Parses the properties for the network service or device. Mostly calls |
| // managed->PropertyChanged(key, value) for each dictionary entry. |
| // |properties| is expected to be type DICTIONARY. |
| void UpdateManagedStateProperties(ManagedState::ManagedType type, |
| const std::string& path, |
| const base::Value& properties) override; |
| |
| // Called by ShillPropertyHandler when a watched service property changes. |
| void UpdateNetworkServiceProperty(const std::string& service_path, |
| const std::string& key, |
| const base::Value& value) override; |
| |
| // Called by ShillPropertyHandler when a watched device property changes. |
| void UpdateDeviceProperty(const std::string& device_path, |
| const std::string& key, |
| const base::Value& value) override; |
| |
| // Called by ShillPropertyHandler when a watched network or device |
| // IPConfig property changes. |properties| is expected to be type DICTIONARY. |
| void UpdateIPConfigProperties(ManagedState::ManagedType type, |
| const std::string& path, |
| const std::string& ip_config_path, |
| const base::Value& properties) override; |
| |
| void CheckPortalListChanged(const std::string& check_portal_list) override; |
| void HostnameChanged(const std::string& hostname) override; |
| void TechnologyListChanged() override; |
| |
| // Called by |shill_property_handler_| when the service or device list has |
| // changed and all entries have been updated. This updates the list and |
| // notifies observers. |
| void ManagedStateListChanged(ManagedState::ManagedType type) override; |
| |
| // Called when the default network service changes. Sets default_network_path_ |
| // and notifies listeners. |
| void DefaultNetworkServiceChanged(const std::string& service_path) override; |
| |
| // Called after construction. Called explicitly by tests after adding |
| // test observers. |
| void InitShillPropertyHandler(); |
| |
| private: |
| typedef std::map<std::string, std::string> SpecifierGuidMap; |
| friend class NetworkStateHandlerTest; |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, NetworkStateHandlerStub); |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, BlockedWifiByPolicyBlocked); |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, |
| BlockedWifiByPolicyOnlyManaged); |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, |
| BlockedCellularByPolicyOnlyManaged); |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, |
| BlockedWifiByPolicyOnlyManagedIfAvailable); |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, SyncStubCellularNetworks); |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, |
| GetNetworkListAfterUpdateManagedList); |
| FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, |
| UpdateBlockedCellularNetworkAfterUpdateManagedList); |
| |
| // Implementation for GetNetworkListByType and GetActiveNetworkListByType. |
| void GetNetworkListByTypeImpl(const NetworkTypePattern& type, |
| bool configured_only, |
| bool visible_only, |
| bool active_only, |
| size_t limit, |
| NetworkStateList* list); |
| |
| // Sorts the network list. Called when all network updates have been received, |
| // or when the network list is requested but the list is in an unsorted state. |
| // Networks are sorted as follows, maintaining the existing relative ordering: |
| // * Connected or connecting networks (should be listed first by Shill) |
| // * Visible non-wifi networks |
| // * Visible wifi networks |
| // * Hidden (wifi) networks |
| void SortNetworkList(); |
| |
| // Updates UMA stats. Called once after all requested networks are updated. |
| void UpdateNetworkStats(); |
| |
| // NetworkState specific method for UpdateManagedStateProperties which |
| // notifies observers. |properties| is expected to be type DICTIONARY. |
| void UpdateNetworkStateProperties(NetworkState* network, |
| const base::Value& properties); |
| |
| // Ensure a valid GUID for NetworkState. |
| void UpdateGuid(NetworkState* network); |
| |
| // Handles cellular network updates by providing some NetworkState properties |
| // from the Cellular DeviceState and alerting receivers if a network has |
| // transitioned from a stub to a Shill-backed network. |
| void HandleCellularNetworkUpdateReceived(NetworkState* network, |
| bool had_icccid_before_update); |
| |
| // Calls AddOrRemoveStubCellularNetworks on StubCellularNetworksProvider if |
| // set and updates GUID for newly added networks as needed. Returns true if |
| // network_list was modified. |
| bool AddOrRemoveStubCellularNetworks(); |
| |
| // Sends NetworkListChanged() to observers and logs an event. |
| void NotifyNetworkListChanged(); |
| |
| // Sends DeviceListChanged() to observers and logs an event. |
| void NotifyDeviceListChanged(); |
| |
| // Non-const getters for managed entries. These are const so that they can |
| // be called by Get[Network|Device]State, even though they return non-const |
| // pointers. |
| DeviceState* GetModifiableDeviceState(const std::string& device_path) const; |
| DeviceState* GetModifiableDeviceStateByType( |
| const NetworkTypePattern& type) const; |
| NetworkState* GetModifiableNetworkState( |
| const std::string& service_path) const; |
| NetworkState* GetModifiableNetworkStateFromGuid( |
| const std::string& guid) const; |
| ManagedState* GetModifiableManagedState(const ManagedStateList* managed_list, |
| const std::string& path) const; |
| |
| // Gets the list specified by |type|. |
| ManagedStateList* GetManagedList(ManagedState::ManagedType type); |
| |
| // Helper function that calls NotifyNetworkConnectionStateChanged and, |
| // for the default network, OnDefaultNetworkConnectionStateChanged and |
| // NotifyDefaultNetworkChanged. |
| void OnNetworkConnectionStateChanged(NetworkState* network); |
| |
| // Verifies the connection state of the default network. Returns false |
| // if the connection state change should be ignored. |
| bool VerifyDefaultNetworkConnectionStateChange(NetworkState* network); |
| |
| // Notifies observers when a network's connection state changes. |
| void NotifyNetworkConnectionStateChanged(NetworkState* network); |
| |
| // Notifies observers when the default network or its properties change. |
| void NotifyDefaultNetworkChanged(const std::string& log_reason); |
| |
| // Notifies observers when the active state of any current or previously |
| // active network changes, or the active networks order changes. |
| bool ActiveNetworksChanged(const NetworkStateList& active_networks); |
| void NotifyIfActiveNetworksChanged(); |
| |
| // Notifies observers about changes to |network|, including IPConfg. |
| void NotifyNetworkPropertiesUpdated(const NetworkState* network); |
| |
| // Notifies observers about changes to |device|, including IPConfigs. |
| void NotifyDevicePropertiesUpdated(const DeviceState* device); |
| |
| // Called to ask observers to scan for networks. |
| void NotifyScanRequested(const NetworkTypePattern& type); |
| |
| // Called whenever Device.Scanning state transitions to true. |
| void NotifyScanStarted(const DeviceState* device); |
| |
| // Called whenever Device.Scanning state transitions to false. |
| void NotifyScanCompleted(const DeviceState* device); |
| |
| // Called when a stub network is replaced by a Shill-backed network. |
| void NotifyNetworkIdentifierTransitioned(const std::string& old_service_path, |
| const std::string& new_service_path, |
| const std::string& old_guid, |
| const std::string& new_guid); |
| |
| // Helper function to log property updated events. |
| void LogPropertyUpdated(const ManagedState* network, |
| const std::string& key, |
| const base::Value& value); |
| |
| // Returns one technology type for |type|. This technology will be the |
| // highest priority technology in the type pattern. |
| std::string GetTechnologyForType(const NetworkTypePattern& type) const; |
| |
| // Returns all the technology types for |type|. |
| std::vector<std::string> GetTechnologiesForType( |
| const NetworkTypePattern& type) const; |
| |
| // Adds Tether networks to |list|, limiting the maximum size of |list| to be |
| // |limit|. If |get_active| is true, only active (i.e., connecting/connected) |
| // networks will be added; otherwise, only inactive networks will be added. |
| // The returned list contains a copy of NetworkState pointers which |
| // should not be stored or used beyond the scope of the calling |
| // function (i.e., they may later become invalid, but only on the UI thread). |
| // See AddTetherNetworkState() for more information about Tether networks. |
| void AppendTetherNetworksToList(bool get_active, |
| size_t limit, |
| NetworkStateList* list); |
| |
| // Set the connection_state of a Tether NetworkState corresponding to the |
| // provided |guid|. |
| void SetTetherNetworkStateConnectionState( |
| const std::string& guid, |
| const std::string& connection_state); |
| |
| // Ensures that the Tether DeviceState is present in |device_list_| if |
| // |tether_technology_state_| is not TECHNOLOGY_UNAVAILABLE and ensures that |
| // it is not present in |device_list_| if it is TECHNOLOGY_UNAVAILABLE. |
| void EnsureTetherDeviceState(); |
| |
| // Updates the network's |blocked_by_policy_| depending on |
| // |allow_only_policy_networks_to_connect_| and |blocked_hex_ssids_|. |
| // Returns true if the value changed. |
| bool UpdateBlockedByPolicy(NetworkState* network) const; |
| |
| // Updates the device's |managed_network_available_| depending on the list of |
| // networks associated with this device. Calls |
| // |UpdateBlockedNetworksInternal(NetworkTypePattern::Wifi())| if the |
| // availability changed. |
| void UpdateManagedWifiNetworkAvailable(); |
| |
| // Check if the cellular device has received update and calls |
| // |UpdateBlockedNetworksInternal(NetworkTypePattern::Cellular())| |
| void UpdateBlockedCellularNetworks(); |
| |
| // Calls |UpdateBlockedByPolicy()| for each given |network_type| network. |
| void UpdateBlockedNetworksInternal(const NetworkTypePattern& network_type); |
| |
| // Sets properties associated with the default network, currently the path and |
| // Metered. |
| void SetDefaultNetworkValues(const std::string& path, bool metered); |
| |
| // Determines whether the user is logged in and sets |is_user_logged_in_|. |
| void ProcessIsUserLoggedIn(const base::Value& profile_list); |
| |
| // Shill property handler instance, owned by this class. |
| std::unique_ptr<internal::ShillPropertyHandler> shill_property_handler_; |
| |
| // Observer list |
| base::ObserverList<NetworkStateHandlerObserver, true>::Unchecked observers_; |
| |
| // List of managed network states |
| ManagedStateList network_list_; |
| |
| // List of managed Tether network states, which exist separately from |
| // |network_list_|. |
| ManagedStateList tether_network_list_; |
| |
| // List of active networks, used to limit ActiveNetworksChanged events. |
| class ActiveNetworkState; |
| std::vector<ActiveNetworkState> active_network_list_; |
| |
| // Set to true when the network list is sorted, cleared when network updates |
| // arrive. Used to trigger sorting when needed. |
| bool network_list_sorted_ = false; |
| |
| // List of managed device states |
| ManagedStateList device_list_; |
| |
| // Keeps track of the default network for notifying observers when it changes. |
| // Do not set this directly, use SetDefaultNetworkValues() instead. |
| std::string default_network_path_; |
| |
| // Tracks whether there is a connected default network and it is metered. |
| // Do not set this directly, use SetDefaultNetworkValues() instead. |
| bool default_network_is_metered_ = false; |
| |
| // List of interfaces on which portal check is enabled. |
| std::string check_portal_list_; |
| |
| // Tracks the default network portal state for triggering PortalStateChanged. |
| NetworkState::PortalState default_network_portal_state_ = |
| NetworkState::PortalState::kUnknown; |
| |
| // Tracks the default network proxy config for triggering PortalStateChanged. |
| base::Value default_network_proxy_config_; |
| |
| // DHCP Hostname. |
| std::string hostname_; |
| |
| // Map of network specifiers to guids. Contains an entry for each |
| // NetworkState that is not saved in a profile. |
| SpecifierGuidMap specifier_guid_map_; |
| |
| // The state corresponding to the Tether device type. This value is managed by |
| // the Tether component. |
| TechnologyState tether_technology_state_ = |
| TechnologyState::TECHNOLOGY_UNAVAILABLE; |
| |
| // Provides stub cellular networks. Not owned by this instance. |
| StubCellularNetworksProvider* stub_cellular_networks_provider_ = nullptr; |
| |
| // Not owned by this instance. |
| const TetherSortDelegate* tether_sort_delegate_ = nullptr; |
| |
| // Ensure that Shutdown() gets called exactly once. |
| bool did_shutdown_ = false; |
| |
| // Ensure that we do not delete any networks while notifying observers. |
| bool notifying_network_observers_ = false; |
| |
| // Policies which control WiFi and Cellular blocking (Controlled from |
| // |ManagedNetworkConfigurationHandler| by calling |UpdateBlockedNetworks()|). |
| bool allow_only_policy_wifi_networks_to_connect_ = false; |
| bool allow_only_policy_wifi_networks_to_connect_if_available_ = false; |
| bool allow_only_policy_cellular_networks_to_connect_ = false; |
| std::vector<std::string> blocked_hex_ssids_; |
| |
| // After login the user's saved networks get updated asynchronously from |
| // shill. These variables indicate whether a user is logged in, and if the |
| // user's saved networks are done updating. |
| bool is_profile_networks_loaded_ = false; |
| bool is_user_logged_in_ = false; |
| |
| SEQUENCE_CHECKER(sequence_checker_); |
| }; |
| |
| } // namespace ash |
| |
| // TODO(https://crbug.com/1164001): remove when the migration is finished. |
| namespace chromeos { |
| using ::ash::NetworkStateHandler; |
| } |
| |
| #endif // CHROMEOS_ASH_COMPONENTS_NETWORK_NETWORK_STATE_HANDLER_H_ |