| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 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. | |
| 4 | |
| 5 #include "chrome/browser/chromeos/net/connectivity_state_helper.h" | |
| 6 | |
| 7 #include "base/command_line.h" | |
| 8 #include "chrome/browser/chromeos/cros/network_library.h" | |
| 9 #include "chromeos/chromeos_switches.h" | |
| 10 #include "chromeos/network/network_state.h" | |
| 11 #include "chromeos/network/network_state_handler.h" | |
| 12 #include "chromeos/network/network_state_handler_observer.h" | |
| 13 #include "third_party/cros_system_api/dbus/service_constants.h" | |
| 14 | |
| 15 namespace chromeos { | |
| 16 | |
| 17 static ConnectivityStateHelper* g_connectivity_state_helper = NULL; | |
| 18 static ConnectivityStateHelper* g_test_connectivity_state_helper = NULL; | |
| 19 | |
| 20 // Implementation of the connectivity state helper that uses the network | |
| 21 // state handler for fetching connectivity state. | |
| 22 class ConnectivityStateHelperImpl | |
| 23 : public ConnectivityStateHelper, | |
| 24 public NetworkStateHandlerObserver { | |
| 25 public: | |
| 26 ConnectivityStateHelperImpl(); | |
| 27 virtual ~ConnectivityStateHelperImpl(); | |
| 28 | |
| 29 // NetworkStateHandler overrides. | |
| 30 virtual bool IsConnected() OVERRIDE; | |
| 31 virtual bool IsConnecting() OVERRIDE; | |
| 32 virtual bool IsConnectedType(const std::string& type) OVERRIDE; | |
| 33 virtual bool IsConnectingType(const std::string& type) OVERRIDE; | |
| 34 virtual std::string NetworkNameForType(const std::string& type) OVERRIDE; | |
| 35 virtual std::string DefaultNetworkName() OVERRIDE; | |
| 36 virtual bool DefaultNetworkOnline() OVERRIDE; | |
| 37 virtual void RequestScan() const OVERRIDE; | |
| 38 | |
| 39 // NetworkStateHandlerObserver overrides. | |
| 40 virtual void NetworkManagerChanged() OVERRIDE; | |
| 41 virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE; | |
| 42 | |
| 43 private: | |
| 44 NetworkStateHandler* network_state_handler_; | |
| 45 }; | |
| 46 | |
| 47 // Implementation of the connectivity state helper that uses the network | |
| 48 // library for fetching connectivity state. | |
| 49 class ConnectivityStateHelperNetworkLibrary | |
| 50 : public ConnectivityStateHelper, | |
| 51 public NetworkLibrary::NetworkManagerObserver { | |
| 52 public: | |
| 53 ConnectivityStateHelperNetworkLibrary(); | |
| 54 virtual ~ConnectivityStateHelperNetworkLibrary(); | |
| 55 | |
| 56 // ConnectivityStateHelper overrides. | |
| 57 virtual bool IsConnected() OVERRIDE; | |
| 58 virtual bool IsConnecting() OVERRIDE; | |
| 59 virtual bool IsConnectedType(const std::string& type) OVERRIDE; | |
| 60 virtual bool IsConnectingType(const std::string& type) OVERRIDE; | |
| 61 virtual std::string NetworkNameForType(const std::string& type) OVERRIDE; | |
| 62 virtual std::string DefaultNetworkName() OVERRIDE; | |
| 63 virtual bool DefaultNetworkOnline() OVERRIDE; | |
| 64 virtual void RequestScan() const OVERRIDE; | |
| 65 | |
| 66 // NetworkLibrary::NetworkManagerObserver overrides. | |
| 67 virtual void OnNetworkManagerChanged( | |
| 68 NetworkLibrary* network_library) OVERRIDE; | |
| 69 | |
| 70 private: | |
| 71 NetworkLibrary* network_library_; | |
| 72 }; | |
| 73 | |
| 74 ConnectivityStateHelper::ConnectivityStateHelper() { | |
| 75 } | |
| 76 | |
| 77 ConnectivityStateHelper::~ConnectivityStateHelper() { | |
| 78 } | |
| 79 | |
| 80 // static | |
| 81 void ConnectivityStateHelper::Initialize() { | |
| 82 CHECK(!g_connectivity_state_helper); | |
| 83 if (!CommandLine::ForCurrentProcess()->HasSwitch( | |
| 84 chromeos::switches::kDisableNewNetworkChangeNotifier)) { | |
| 85 g_connectivity_state_helper = new ConnectivityStateHelperImpl(); | |
| 86 } else { | |
| 87 g_connectivity_state_helper = | |
| 88 new ConnectivityStateHelperNetworkLibrary(); | |
| 89 } | |
| 90 } | |
| 91 | |
| 92 // static | |
| 93 bool ConnectivityStateHelper::IsInitialized() { | |
| 94 return g_connectivity_state_helper != NULL; | |
| 95 } | |
| 96 | |
| 97 // static | |
| 98 void ConnectivityStateHelper::Shutdown() { | |
| 99 CHECK(g_connectivity_state_helper); | |
| 100 delete g_connectivity_state_helper; | |
| 101 g_connectivity_state_helper = NULL; | |
| 102 } | |
| 103 | |
| 104 // static | |
| 105 ConnectivityStateHelper* ConnectivityStateHelper::Get() { | |
| 106 CHECK(g_connectivity_state_helper || g_test_connectivity_state_helper) | |
| 107 << "ConnectivityStateHelper: Get() called before Initialize()"; | |
| 108 if (g_test_connectivity_state_helper) | |
| 109 return g_test_connectivity_state_helper; | |
| 110 return g_connectivity_state_helper; | |
| 111 } | |
| 112 | |
| 113 // static | |
| 114 void ConnectivityStateHelper::SetForTest(ConnectivityStateHelper* impl) { | |
| 115 CHECK(!g_test_connectivity_state_helper || !impl); | |
| 116 g_test_connectivity_state_helper = impl; | |
| 117 } | |
| 118 | |
| 119 void ConnectivityStateHelper::AddNetworkManagerObserver( | |
| 120 ConnectivityStateHelperObserver* observer) { | |
| 121 connectivity_observers_.AddObserver(observer); | |
| 122 } | |
| 123 | |
| 124 void ConnectivityStateHelper::RemoveNetworkManagerObserver( | |
| 125 ConnectivityStateHelperObserver* observer) { | |
| 126 connectivity_observers_.RemoveObserver(observer); | |
| 127 } | |
| 128 | |
| 129 ConnectivityStateHelperImpl::ConnectivityStateHelperImpl() { | |
| 130 network_state_handler_ = NetworkHandler::Get()->network_state_handler(); | |
| 131 network_state_handler_->AddObserver(this, FROM_HERE); | |
| 132 } | |
| 133 | |
| 134 ConnectivityStateHelperImpl::~ConnectivityStateHelperImpl() { | |
| 135 network_state_handler_->RemoveObserver(this, FROM_HERE); | |
| 136 } | |
| 137 | |
| 138 bool ConnectivityStateHelperImpl::IsConnected() { | |
| 139 return network_state_handler_->ConnectedNetworkByType( | |
| 140 NetworkStateHandler::kMatchTypeDefault) != NULL; | |
| 141 } | |
| 142 | |
| 143 bool ConnectivityStateHelperImpl::IsConnecting() { | |
| 144 return network_state_handler_->ConnectingNetworkByType( | |
| 145 NetworkStateHandler::kMatchTypeDefault) != NULL; | |
| 146 } | |
| 147 | |
| 148 bool ConnectivityStateHelperImpl::IsConnectedType( | |
| 149 const std::string& type) { | |
| 150 return network_state_handler_->ConnectedNetworkByType(type) != NULL; | |
| 151 } | |
| 152 | |
| 153 bool ConnectivityStateHelperImpl::IsConnectingType( | |
| 154 const std::string& type) { | |
| 155 return network_state_handler_->ConnectingNetworkByType(type) != NULL; | |
| 156 } | |
| 157 | |
| 158 std::string ConnectivityStateHelperImpl::NetworkNameForType( | |
| 159 const std::string& type) { | |
| 160 const NetworkState* network = network_state_handler_-> | |
| 161 ConnectedNetworkByType(type); | |
| 162 if (!network) | |
| 163 network = network_state_handler_->ConnectingNetworkByType(type); | |
| 164 return network ? network->name() : std::string(); | |
| 165 } | |
| 166 | |
| 167 std::string ConnectivityStateHelperImpl::DefaultNetworkName() { | |
| 168 const NetworkState* default_network = network_state_handler_-> | |
| 169 DefaultNetwork(); | |
| 170 return default_network ? default_network->name() : std::string(); | |
| 171 } | |
| 172 | |
| 173 bool ConnectivityStateHelperImpl::DefaultNetworkOnline() { | |
| 174 const NetworkState* network = network_state_handler_->DefaultNetwork(); | |
| 175 if (!network) | |
| 176 return false; | |
| 177 if (!network->IsConnectedState()) | |
| 178 return false; | |
| 179 if (network->connection_state() == flimflam::kStatePortal) | |
| 180 return false; | |
| 181 return true; | |
| 182 } | |
| 183 | |
| 184 void ConnectivityStateHelperImpl::RequestScan() const { | |
| 185 network_state_handler_->RequestScan(); | |
| 186 } | |
| 187 | |
| 188 void ConnectivityStateHelperImpl::NetworkManagerChanged() { | |
| 189 FOR_EACH_OBSERVER(ConnectivityStateHelperObserver, connectivity_observers_, | |
| 190 NetworkManagerChanged()); | |
| 191 } | |
| 192 | |
| 193 void ConnectivityStateHelperImpl::DefaultNetworkChanged( | |
| 194 const NetworkState* network) { | |
| 195 FOR_EACH_OBSERVER(ConnectivityStateHelperObserver, connectivity_observers_, | |
| 196 DefaultNetworkChanged()); | |
| 197 } | |
| 198 | |
| 199 //////////////////////////////////////////////////////////////////////////////// | |
| 200 // NetworkLibrary implementation. | |
| 201 // | |
| 202 | |
| 203 ConnectivityStateHelperNetworkLibrary::ConnectivityStateHelperNetworkLibrary() { | |
| 204 network_library_ = NetworkLibrary::Get(); | |
| 205 network_library_->AddNetworkManagerObserver(this); | |
| 206 } | |
| 207 | |
| 208 ConnectivityStateHelperNetworkLibrary::~ConnectivityStateHelperNetworkLibrary() | |
| 209 { | |
| 210 network_library_->RemoveNetworkManagerObserver(this); | |
| 211 } | |
| 212 | |
| 213 bool ConnectivityStateHelperNetworkLibrary::IsConnected() { | |
| 214 return network_library_->Connected(); | |
| 215 } | |
| 216 | |
| 217 bool ConnectivityStateHelperNetworkLibrary::IsConnecting() { | |
| 218 return network_library_->Connecting(); | |
| 219 } | |
| 220 | |
| 221 bool ConnectivityStateHelperNetworkLibrary::IsConnectedType( | |
| 222 const std::string& type) { | |
| 223 if (type == flimflam::kTypeEthernet) | |
| 224 return network_library_->ethernet_connected(); | |
| 225 if (type == flimflam::kTypeWifi) | |
| 226 return network_library_->wifi_connected(); | |
| 227 if (type == flimflam::kTypeCellular) | |
| 228 return network_library_->cellular_connected(); | |
| 229 if (type == flimflam::kTypeWimax) | |
| 230 return network_library_->wimax_connected(); | |
| 231 return false; | |
| 232 } | |
| 233 | |
| 234 bool ConnectivityStateHelperNetworkLibrary::IsConnectingType( | |
| 235 const std::string& type) { | |
| 236 if (type == flimflam::kTypeEthernet) | |
| 237 return network_library_->ethernet_connecting(); | |
| 238 if (type == flimflam::kTypeWifi) | |
| 239 return network_library_->wifi_connecting(); | |
| 240 if (type == flimflam::kTypeCellular) | |
| 241 return network_library_->cellular_connecting(); | |
| 242 if (type == flimflam::kTypeWimax) | |
| 243 return network_library_->wimax_connecting(); | |
| 244 return false; | |
| 245 } | |
| 246 | |
| 247 std::string ConnectivityStateHelperNetworkLibrary::NetworkNameForType( | |
| 248 const std::string& type) { | |
| 249 if (type == flimflam::kTypeEthernet && network_library_->ethernet_network()) | |
| 250 return network_library_->ethernet_network()->name(); | |
| 251 if (type == flimflam::kTypeWifi && network_library_->wifi_network()) | |
| 252 return network_library_->wifi_network()->name(); | |
| 253 if (type == flimflam::kTypeCellular && network_library_->cellular_network()) | |
| 254 return network_library_->cellular_network()->name(); | |
| 255 if (type == flimflam::kTypeWimax && network_library_->wimax_network()) | |
| 256 return network_library_->wimax_network()->name(); | |
| 257 return std::string(); | |
| 258 } | |
| 259 | |
| 260 std::string ConnectivityStateHelperNetworkLibrary::DefaultNetworkName() { | |
| 261 if (network_library_->active_network()) | |
| 262 return network_library_->active_network()->name(); | |
| 263 return std::string(); | |
| 264 } | |
| 265 | |
| 266 bool ConnectivityStateHelperNetworkLibrary::DefaultNetworkOnline() { | |
| 267 const Network* active_network = network_library_->active_network(); | |
| 268 if (!active_network) | |
| 269 return false; | |
| 270 if (!active_network->connected()) | |
| 271 return false; | |
| 272 if (active_network->restricted_pool()) | |
| 273 return false; | |
| 274 return true; | |
| 275 } | |
| 276 | |
| 277 void ConnectivityStateHelperNetworkLibrary::RequestScan() const { | |
| 278 network_library_->RequestNetworkScan(); | |
| 279 } | |
| 280 | |
| 281 void ConnectivityStateHelperNetworkLibrary::OnNetworkManagerChanged( | |
| 282 NetworkLibrary* network_library) { | |
| 283 FOR_EACH_OBSERVER(ConnectivityStateHelperObserver, connectivity_observers_, | |
| 284 NetworkManagerChanged()); | |
| 285 } | |
| 286 | |
| 287 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 22264004:
Remove ConnectivityStateHelper (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src