Don't preload rarely seen large images
[chromium-blink-merge.git] / chromeos / network / shill_property_handler.h
blob8b2cd42732217a63e9f855e211c72dc0b191ed65
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CHROMEOS_NETWORK_SHILL_PROPERTY_HANDLER_H_
6 #define CHROMEOS_NETWORK_SHILL_PROPERTY_HANDLER_H_
8 #include <list>
9 #include <map>
10 #include <set>
11 #include <string>
13 #include "base/memory/weak_ptr.h"
14 #include "chromeos/dbus/dbus_method_call_status.h"
15 #include "chromeos/dbus/shill_property_changed_observer.h"
16 #include "chromeos/network/managed_state.h"
17 #include "chromeos/network/network_handler_callbacks.h"
19 namespace base {
20 class DictionaryValue;
21 class ListValue;
22 class Value;
25 namespace chromeos {
27 class ShillManagerClient;
29 namespace internal {
31 class ShillPropertyObserver;
33 // This class handles Shill calls and observers to reflect the state of the
34 // Shill Manager and its services and devices. It observes Shill.Manager and
35 // requests properties for new devices/networks. It takes a Listener in its
36 // constructor (e.g. NetworkStateHandler) that it calls when properties change
37 // (including once to set their initial state after Init() gets called).
38 // It also observes Shill.Service for all services in Manager.ServiceWatchList.
39 // This class must not outlive the ShillManagerClient instance.
40 class CHROMEOS_EXPORT ShillPropertyHandler
41 : public ShillPropertyChangedObserver,
42 public base::SupportsWeakPtr<ShillPropertyHandler> {
43 public:
44 typedef std::map<std::string, ShillPropertyObserver*>
45 ShillPropertyObserverMap;
47 class CHROMEOS_EXPORT Listener {
48 public:
49 // Called when the entries in a managed list have changed.
50 virtual void UpdateManagedList(ManagedState::ManagedType type,
51 const base::ListValue& entries) = 0;
53 // Called when the properties for a managed state have changed.
54 virtual void UpdateManagedStateProperties(
55 ManagedState::ManagedType type,
56 const std::string& path,
57 const base::DictionaryValue& properties) = 0;
59 // Called when the list of profiles changes.
60 virtual void ProfileListChanged() = 0;
62 // Called when a property for a watched network service has changed.
63 virtual void UpdateNetworkServiceProperty(
64 const std::string& service_path,
65 const std::string& key,
66 const base::Value& value) = 0;
68 // Called when a property for a watched device has changed.
69 virtual void UpdateDeviceProperty(
70 const std::string& device_path,
71 const std::string& key,
72 const base::Value& value) = 0;
74 // Called when a watched network or device IPConfig property changes.
75 virtual void UpdateIPConfigProperties(
76 ManagedState::ManagedType type,
77 const std::string& path,
78 const std::string& ip_config_path,
79 const base::DictionaryValue& properties) = 0;
81 // Called when the list of devices with portal check enabled changes.
82 virtual void CheckPortalListChanged(
83 const std::string& check_portal_list) = 0;
85 // Called when a technology list changes.
86 virtual void TechnologyListChanged() = 0;
88 // Called when a managed state list has changed, after properties for any
89 // new entries in the list have been received and
90 // UpdateManagedStateProperties has been called for each new entry.
91 virtual void ManagedStateListChanged(ManagedState::ManagedType type) = 0;
93 // Called when the default network service changes.
94 virtual void DefaultNetworkServiceChanged(
95 const std::string& service_path) = 0;
97 protected:
98 virtual ~Listener() {}
101 explicit ShillPropertyHandler(Listener* listener);
102 ~ShillPropertyHandler() override;
104 // Sets up the observer and calls UpdateManagerProperties().
105 void Init();
107 // Requests all Manager properties. Called from Init() and any time
108 // properties that do not signal changes might have been updated (e.g.
109 // ServiceCompleteList).
110 void UpdateManagerProperties();
112 // Returns true if |technology| is available, enabled, etc.
113 bool IsTechnologyAvailable(const std::string& technology) const;
114 bool IsTechnologyEnabled(const std::string& technology) const;
115 bool IsTechnologyEnabling(const std::string& technology) const;
116 bool IsTechnologyUninitialized(const std::string& technology) const;
118 // Asynchronously sets the enabled state for |technology|.
119 // Note: Modifies Manager state. Calls |error_callback| on failure.
120 void SetTechnologyEnabled(
121 const std::string& technology,
122 bool enabled,
123 const network_handler::ErrorCallback& error_callback);
125 // Sets the list of devices on which portal check is enabled.
126 void SetCheckPortalList(const std::string& check_portal_list);
128 // Sets the Manager.WakeOnLan property. Note: we do not track this state, we
129 // only set it.
130 void SetWakeOnLanEnabled(bool enabled);
132 // Requests an immediate network scan.
133 void RequestScan() const;
135 // Requests all properties for the service or device (called for new items).
136 void RequestProperties(ManagedState::ManagedType type,
137 const std::string& path);
139 // ShillPropertyChangedObserver overrides
140 void OnPropertyChanged(const std::string& key,
141 const base::Value& value) override;
143 private:
144 typedef std::map<ManagedState::ManagedType, std::set<std::string> >
145 TypeRequestMap;
147 // Callback for dbus method fetching properties.
148 void ManagerPropertiesCallback(DBusMethodCallStatus call_status,
149 const base::DictionaryValue& properties);
151 // Notifies the listener when a ManagedStateList has changed and all pending
152 // updates have been received. |key| can either identify the list that
153 // has changed or an empty string if multiple lists may have changed.
154 void CheckPendingStateListUpdates(const std::string& key);
156 // Called form OnPropertyChanged() and ManagerPropertiesCallback().
157 void ManagerPropertyChanged(const std::string& key,
158 const base::Value& value);
160 // Requests properties for new entries in the list for |type|.
161 void UpdateProperties(ManagedState::ManagedType type,
162 const base::ListValue& entries);
164 // Updates the Shill property observers to observe any entries for |type|.
165 void UpdateObserved(ManagedState::ManagedType type,
166 const base::ListValue& entries);
169 // Sets |*_technologies_| to contain only entries in |technologies|.
170 void UpdateAvailableTechnologies(const base::ListValue& technologies);
171 void UpdateEnabledTechnologies(const base::ListValue& technologies);
172 void UpdateUninitializedTechnologies(const base::ListValue& technologies);
174 void EnableTechnologyFailed(
175 const std::string& technology,
176 const network_handler::ErrorCallback& error_callback,
177 const std::string& dbus_error_name,
178 const std::string& dbus_error_message);
180 // Called when Shill returns the properties for a service or device.
181 void GetPropertiesCallback(ManagedState::ManagedType type,
182 const std::string& path,
183 DBusMethodCallStatus call_status,
184 const base::DictionaryValue& properties);
186 // Callback invoked when a watched property changes. Calls appropriate
187 // handlers and signals observers.
188 void PropertyChangedCallback(ManagedState::ManagedType type,
189 const std::string& path,
190 const std::string& key,
191 const base::Value& value);
193 // Request a single IPConfig object corresponding to |ip_config_path_value|
194 // from Shill.IPConfigClient and trigger a call to UpdateIPConfigProperties
195 // for the network or device corresponding to |type| and |path|.
196 void RequestIPConfig(ManagedState::ManagedType type,
197 const std::string& path,
198 const base::Value& ip_config_path_value);
200 // Request the IPConfig objects corresponding to entries in
201 // |ip_config_list_value| from Shill.IPConfigClient and trigger a call to
202 // UpdateIPConfigProperties with each object for the network or device
203 // corresponding to |type| and |path|.
204 void RequestIPConfigsList(ManagedState::ManagedType type,
205 const std::string& path,
206 const base::Value& ip_config_list_value);
208 // Callback for getting the IPConfig property of a network or device. Handled
209 // here instead of in NetworkState so that all asynchronous requests are done
210 // in a single place (also simplifies NetworkState considerably).
211 void GetIPConfigCallback(ManagedState::ManagedType type,
212 const std::string& path,
213 const std::string& ip_config_path,
214 DBusMethodCallStatus call_status,
215 const base::DictionaryValue& properties);
217 // Pointer to containing class (owns this)
218 Listener* listener_;
220 // Convenience pointer for ShillManagerClient
221 ShillManagerClient* shill_manager_;
223 // Pending update list for each managed state type
224 TypeRequestMap pending_updates_;
226 // List of states for which properties have been requested, for each managed
227 // state type
228 TypeRequestMap requested_updates_;
230 // List of network services with Shill property changed observers
231 ShillPropertyObserverMap observed_networks_;
233 // List of network devices with Shill property changed observers
234 ShillPropertyObserverMap observed_devices_;
236 // Lists of available / enabled / uninitialized technologies
237 std::set<std::string> available_technologies_;
238 std::set<std::string> enabled_technologies_;
239 std::set<std::string> enabling_technologies_;
240 std::set<std::string> uninitialized_technologies_;
242 DISALLOW_COPY_AND_ASSIGN(ShillPropertyHandler);
245 } // namespace internal
246 } // namespace chromeos
248 #endif // CHROMEOS_NETWORK_SHILL_PROPERTY_HANDLER_H_