summaryrefslogtreecommitdiffstats
path: root/chrome/browser/chromeos/cros
diff options
context:
space:
mode:
Diffstat (limited to 'chrome/browser/chromeos/cros')
-rw-r--r--chrome/browser/chromeos/cros/cros_mock.cc62
-rw-r--r--chrome/browser/chromeos/cros/cryptohome_library.cc2
-rw-r--r--chrome/browser/chromeos/cros/input_method_library.cc83
-rw-r--r--chrome/browser/chromeos/cros/login_library.cc53
-rw-r--r--chrome/browser/chromeos/cros/mock_network_library.h43
-rw-r--r--chrome/browser/chromeos/cros/mock_update_library.h3
-rw-r--r--chrome/browser/chromeos/cros/network_library.cc1290
-rw-r--r--chrome/browser/chromeos/cros/network_library.h232
-rw-r--r--chrome/browser/chromeos/cros/power_library.cc13
-rw-r--r--chrome/browser/chromeos/cros/screen_lock_library.cc37
-rw-r--r--chrome/browser/chromeos/cros/syslogs_library.cc21
-rw-r--r--chrome/browser/chromeos/cros/syslogs_library.h2
-rw-r--r--chrome/browser/chromeos/cros/system_library.cc4
-rw-r--r--chrome/browser/chromeos/cros/update_library.cc16
-rw-r--r--chrome/browser/chromeos/cros/update_library.h9
15 files changed, 1218 insertions, 652 deletions
diff --git a/chrome/browser/chromeos/cros/cros_mock.cc b/chrome/browser/chromeos/cros/cros_mock.cc
index ab33dc0..5e66df0 100644
--- a/chrome/browser/chromeos/cros/cros_mock.cc
+++ b/chrome/browser/chromeos/cros/cros_mock.cc
@@ -29,6 +29,8 @@
namespace chromeos {
using ::testing::AnyNumber;
+using ::testing::AtMost;
+using ::testing::InSequence;
using ::testing::InvokeWithoutArgs;
using ::testing::Return;
using ::testing::ReturnRef;
@@ -268,24 +270,19 @@ void CrosMock::SetInputMethodLibraryStatusAreaExpectations() {
}
void CrosMock::SetNetworkLibraryStatusAreaExpectations() {
- EXPECT_CALL(*mock_network_library_, AddObserver(_))
+ EXPECT_CALL(*mock_network_library_, AddNetworkManagerObserver(_))
.Times(1)
.RetiresOnSaturation();
-
- // NetworkDropdownButton::NetworkChanged() calls:
- EXPECT_CALL(*mock_network_library_, ethernet_connected())
- .Times(2) // also called by NetworkMenu::InitMenuItems()
- .WillRepeatedly((Return(false)))
- .RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, wifi_connected())
+ EXPECT_CALL(*mock_network_library_, AddCellularDataPlanObserver(_))
.Times(1)
- .WillRepeatedly((Return(false)))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, wifi_connecting())
+
+ // NetworkMenuButton::OnNetworkManagerChanged() calls:
+ EXPECT_CALL(*mock_network_library_, active_network())
.Times(1)
- .WillRepeatedly((Return(false)))
+ .WillRepeatedly((Return((const Network*)(NULL))))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, cellular_connected())
+ EXPECT_CALL(*mock_network_library_, wifi_connecting())
.Times(1)
.WillRepeatedly((Return(false)))
.RetiresOnSaturation();
@@ -294,7 +291,7 @@ void CrosMock::SetNetworkLibraryStatusAreaExpectations() {
.WillRepeatedly((Return(false)))
.RetiresOnSaturation();
EXPECT_CALL(*mock_network_library_, Connected())
- .Times(2) // also called by NetworkMenu::InitMenuItems()
+ .Times(2)
.WillRepeatedly((Return(false)))
.RetiresOnSaturation();
EXPECT_CALL(*mock_network_library_, Connecting())
@@ -303,36 +300,38 @@ void CrosMock::SetNetworkLibraryStatusAreaExpectations() {
.RetiresOnSaturation();
// NetworkMenu::InitMenuItems() calls:
- EXPECT_CALL(*mock_network_library_, ethernet_connecting())
+ EXPECT_CALL(*mock_network_library_, ethernet_available())
+ .Times(1)
+ .WillRepeatedly((Return(true)))
+ .RetiresOnSaturation();
+ EXPECT_CALL(*mock_network_library_, ethernet_connected())
.Times(1)
.WillRepeatedly((Return(false)))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, wifi_networks())
+ EXPECT_CALL(*mock_network_library_, ethernet_connecting())
.Times(1)
- .WillRepeatedly((ReturnRef(wifi_networks_)))
+ .WillRepeatedly((Return(false)))
.RetiresOnSaturation();
EXPECT_CALL(*mock_network_library_, wifi_available())
.Times(1)
.WillRepeatedly((Return(false)))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, wifi_network())
+ EXPECT_CALL(*mock_network_library_, cellular_available())
.Times(1)
- .WillRepeatedly((ReturnRef(wifi_network_)))
+ .WillRepeatedly((Return(false)))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, cellular_networks())
+ EXPECT_CALL(*mock_network_library_, Connected())
.Times(1)
- .WillRepeatedly((ReturnRef(cellular_networks_)))
+ .WillRepeatedly((Return(false)))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, cellular_network())
+
+ EXPECT_CALL(*mock_network_library_, RemoveNetworkManagerObserver(_))
.Times(1)
- .WillRepeatedly((ReturnRef(cellular_network_)))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_network_library_, cellular_available())
+ EXPECT_CALL(*mock_network_library_, RemoveObserverForAllNetworks(_))
.Times(1)
- .WillRepeatedly((Return(false)))
.RetiresOnSaturation();
-
- EXPECT_CALL(*mock_network_library_, RemoveObserver(_))
+ EXPECT_CALL(*mock_network_library_, RemoveCellularDataPlanObserver(_))
.Times(1)
.RetiresOnSaturation();
}
@@ -378,17 +377,20 @@ void CrosMock::SetPowerLibraryExpectations() {
}
void CrosMock::SetSpeechSynthesisLibraryExpectations() {
+ InSequence s;
+ EXPECT_CALL(*mock_speech_synthesis_library_, StopSpeaking())
+ .WillOnce(Return(true))
+ .RetiresOnSaturation();
EXPECT_CALL(*mock_speech_synthesis_library_, Speak(_))
- .Times(1)
.WillOnce(Return(true))
.RetiresOnSaturation();
EXPECT_CALL(*mock_speech_synthesis_library_, StopSpeaking())
- .Times(1)
.WillOnce(Return(true))
.RetiresOnSaturation();
- EXPECT_CALL(*mock_speech_synthesis_library_, IsSpeaking())
- .Times(4)
+ EXPECT_CALL(*mock_speech_synthesis_library_, Speak(_))
.WillOnce(Return(true))
+ .RetiresOnSaturation();
+ EXPECT_CALL(*mock_speech_synthesis_library_, IsSpeaking())
.WillOnce(Return(true))
.WillOnce(Return(true))
.WillOnce(Return(false))
diff --git a/chrome/browser/chromeos/cros/cryptohome_library.cc b/chrome/browser/chromeos/cros/cryptohome_library.cc
index 52ce85c..cd9a31d 100644
--- a/chrome/browser/chromeos/cros/cryptohome_library.cc
+++ b/chrome/browser/chromeos/cros/cryptohome_library.cc
@@ -163,7 +163,7 @@ class CryptohomeLibraryImpl : public CryptohomeLibrary {
LOG(ERROR) << error;
return false;
}
- LOG(INFO) << "Adding handler for " << async_id;
+ VLOG(1) << "Adding handler for " << async_id;
callback_map_[async_id] = d;
return true;
}
diff --git a/chrome/browser/chromeos/cros/input_method_library.cc b/chrome/browser/chromeos/cros/input_method_library.cc
index 62ffbb1..bdf3318 100644
--- a/chrome/browser/chromeos/cros/input_method_library.cc
+++ b/chrome/browser/chromeos/cros/input_method_library.cc
@@ -60,8 +60,7 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
defer_ime_startup_(false),
should_change_input_method_(false),
ibus_daemon_process_id_(0),
- candidate_window_process_id_(0),
- failure_count_(0) {
+ candidate_window_process_id_(0) {
scoped_ptr<InputMethodDescriptors> input_method_descriptors(
CreateFallbackInputMethodDescriptors());
current_input_method_ = input_method_descriptors->at(0);
@@ -124,8 +123,7 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
if (input_method_id != chromeos::GetHardwareKeyboardLayoutName()) {
StartInputMethodProcesses();
}
- chromeos::ChangeInputMethod(
- input_method_status_connection_, input_method_id.c_str());
+ ChangeInputMethodInternal(input_method_id);
}
}
@@ -139,7 +137,7 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
bool InputMethodIsActivated(const std::string& input_method_id) {
scoped_ptr<InputMethodDescriptors> active_input_method_descriptors(
- CrosLibrary::Get()->GetInputMethodLibrary()->GetActiveInputMethods());
+ GetActiveInputMethods());
for (size_t i = 0; i < active_input_method_descriptors->size(); ++i) {
if (active_input_method_descriptors->at(i).id == input_method_id) {
return true;
@@ -206,6 +204,39 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
}
}
+ // Changes the current input method to |input_method_id|. If the id is not in
+ // the preload_engine list, this function changes the current method to the
+ // first preloaded engine. Returns true if the current engine is switched to
+ // |input_method_id| or the first one.
+ bool ChangeInputMethodInternal(const std::string& input_method_id) {
+ DCHECK(EnsureLoadedAndStarted());
+ std::string input_method_id_to_switch = input_method_id;
+
+ if (!InputMethodIsActivated(input_method_id)) {
+ // This path might be taken if prefs::kLanguageCurrentInputMethod (NOT
+ // synced with cloud) and kLanguagePreloadEngines (synced with cloud) are
+ // mismatched. e.g. the former is 'xkb:us::eng' and the latter (on the
+ // sync server) is 'xkb:jp::jpn,mozc'.
+ scoped_ptr<InputMethodDescriptors> input_methods(GetActiveInputMethods());
+ DCHECK(!input_methods->empty());
+ if (!input_methods->empty()) {
+ input_method_id_to_switch = input_methods->at(0).id;
+ LOG(INFO) << "Can't change the current input method to "
+ << input_method_id << " since the engine is not preloaded. "
+ << "Switch to " << input_method_id_to_switch << " instead.";
+ }
+ }
+
+ if (chromeos::ChangeInputMethod(input_method_status_connection_,
+ input_method_id_to_switch.c_str())) {
+ return true;
+ }
+
+ // Not reached.
+ LOG(ERROR) << "Can't switch input method to " << input_method_id_to_switch;
+ return false;
+ }
+
// Flushes the input method config data. The config data is queued up in
// |pending_config_requests_| until the config backend (ibus-memconf)
// starts. Since there is no good way to get notified when the config
@@ -213,7 +244,6 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
// config data to the config backend.
void FlushImeConfig() {
bool active_input_methods_are_changed = false;
- bool completed = false;
if (EnsureLoadedAndStarted()) {
InputMethodConfigRequests::iterator iter =
pending_config_requests_.begin();
@@ -241,41 +271,22 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
// yet been added to preload_engines. As such, the call is deferred
// until after all config values have been sent to the IME process.
if (should_change_input_method_) {
- if (chromeos::ChangeInputMethod(input_method_status_connection_,
- current_input_method_id_.c_str())) {
- should_change_input_method_ = false;
- completed = true;
- active_input_methods_are_changed = true;
- }
- } else {
- completed = true;
+ ChangeInputMethodInternal(current_input_method_id_);
+ should_change_input_method_ = false;
+ active_input_methods_are_changed = true;
}
}
}
- if (completed) {
+ if (pending_config_requests_.empty()) {
timer_.Stop(); // no-op if it's not running.
- } else {
+ } else if (!timer_.IsRunning()) {
// Flush is not completed. Start a timer if it's not yet running.
- if (!timer_.IsRunning()) {
- static const int64 kTimerIntervalInMsec = 100;
- failure_count_ = 0;
- timer_.Start(base::TimeDelta::FromMilliseconds(kTimerIntervalInMsec),
- this, &InputMethodLibraryImpl::FlushImeConfig);
- } else {
- // The timer is already running. We'll give up if it reaches the
- // max retry count.
- static const int kMaxRetries = 15;
- ++failure_count_;
- if (failure_count_ > kMaxRetries) {
- LOG(ERROR) << "FlushImeConfig: Max retries exceeded. "
- << "current_input_method_id: " << current_input_method_id_
- << " pending_config_requests.size: "
- << pending_config_requests_.size();
- timer_.Stop();
- }
- }
+ static const int64 kTimerIntervalInMsec = 100;
+ timer_.Start(base::TimeDelta::FromMilliseconds(kTimerIntervalInMsec),
+ this, &InputMethodLibraryImpl::FlushImeConfig);
}
+
if (active_input_methods_are_changed) {
FOR_EACH_OBSERVER(Observer, observers_, ActiveInputMethodsChanged(this));
}
@@ -495,7 +506,7 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
}
void SetDeferImeStartup(bool defer) {
- LOG(INFO) << "Setting DeferImeStartup to " << defer;
+ VLOG(1) << "Setting DeferImeStartup to " << defer;
defer_ime_startup_ = defer;
}
@@ -560,8 +571,6 @@ class InputMethodLibraryImpl : public InputMethodLibrary,
int ibus_daemon_process_id_;
// The process id of the candidate window. 0 if it's not running.
int candidate_window_process_id_;
- // The failure count of config flush attempts.
- int failure_count_;
DISALLOW_COPY_AND_ASSIGN(InputMethodLibraryImpl);
};
diff --git a/chrome/browser/chromeos/cros/login_library.cc b/chrome/browser/chromeos/cros/login_library.cc
index 73ae346..5af80e9 100644
--- a/chrome/browser/chromeos/cros/login_library.cc
+++ b/chrome/browser/chromeos/cros/login_library.cc
@@ -31,13 +31,27 @@ class LoginLibraryImpl : public LoginLibrary {
bool CheckWhitelist(const std::string& email,
std::vector<uint8>* OUT_signature) {
- return chromeos::CheckWhitelist(email.c_str(), OUT_signature);
+ CryptoBlob* sig = NULL;
+ if (chromeos::CheckWhitelistSafe(email.c_str(), &sig)) {
+ OUT_signature->assign(sig->data, sig->data + sig->length);
+ chromeos::FreeCryptoBlob(sig);
+ return true;
+ }
+ return false;
}
bool RetrieveProperty(const std::string& name,
std::string* OUT_value,
std::vector<uint8>* OUT_signature) {
- return chromeos::RetrieveProperty(name.c_str(), OUT_value, OUT_signature);
+ Property* prop = NULL;
+ if (chromeos::RetrievePropertySafe(name.c_str(), &prop)) {
+ OUT_value->assign(prop->value);
+ CryptoBlob* sig = prop->signature;
+ OUT_signature->assign(sig->data, sig->data + sig->length);
+ chromeos::FreeProperty(prop);
+ return true;
+ }
+ return false;
}
bool SetOwnerKeyAsync(const std::vector<uint8>& public_key_der,
@@ -46,7 +60,11 @@ class LoginLibraryImpl : public LoginLibrary {
if (set_owner_key_callback_)
return false;
set_owner_key_callback_ = callback;
- return chromeos::SetOwnerKey(public_key_der);
+ CryptoBlob* key = chromeos::CreateCryptoBlob(&public_key_der[0],
+ public_key_der.size());
+ bool rv = chromeos::SetOwnerKeySafe(key);
+ chromeos::FreeCryptoBlob(key);
+ return rv;
}
bool StorePropertyAsync(const std::string& name,
@@ -57,7 +75,13 @@ class LoginLibraryImpl : public LoginLibrary {
if (property_op_callback_)
return false;
property_op_callback_ = callback;
- return chromeos::StoreProperty(name.c_str(), value.c_str(), signature);
+ Property* prop = chromeos::CreateProperty(name.c_str(),
+ value.c_str(),
+ &signature[0],
+ signature.size());
+ bool rv = chromeos::StorePropertySafe(prop);
+ chromeos::FreeProperty(prop);
+ return rv;
}
bool UnwhitelistAsync(const std::string& email,
@@ -67,7 +91,11 @@ class LoginLibraryImpl : public LoginLibrary {
if (whitelist_op_callback_)
return false;
whitelist_op_callback_ = callback;
- return chromeos::Unwhitelist(email.c_str(), signature);
+ CryptoBlob* sig = chromeos::CreateCryptoBlob(&signature[0],
+ signature.size());
+ bool rv = chromeos::UnwhitelistSafe(email.c_str(), sig);
+ chromeos::FreeCryptoBlob(sig);
+ return rv;
}
bool WhitelistAsync(const std::string& email,
@@ -77,11 +105,22 @@ class LoginLibraryImpl : public LoginLibrary {
if (whitelist_op_callback_)
return false;
whitelist_op_callback_ = callback;
- return chromeos::Whitelist(email.c_str(), signature);
+ CryptoBlob* sig = chromeos::CreateCryptoBlob(&signature[0],
+ signature.size());
+ bool rv = chromeos::WhitelistSafe(email.c_str(), sig);
+ chromeos::FreeCryptoBlob(sig);
+ return rv;
}
bool EnumerateWhitelisted(std::vector<std::string>* whitelisted) {
- return chromeos::EnumerateWhitelisted(whitelisted);
+ UserList* list = NULL;
+ if (chromeos::EnumerateWhitelistedSafe(&list)) {
+ for (int i = 0; i < list->num_users; i++)
+ whitelisted->push_back(std::string(list->users[i]));
+ chromeos::FreeUserList(list);
+ return true;
+ }
+ return false;
}
bool StartSession(const std::string& user_email,
diff --git a/chrome/browser/chromeos/cros/mock_network_library.h b/chrome/browser/chromeos/cros/mock_network_library.h
index 1e43e35..21b9bf4 100644
--- a/chrome/browser/chromeos/cros/mock_network_library.h
+++ b/chrome/browser/chromeos/cros/mock_network_library.h
@@ -17,16 +17,22 @@ class MockNetworkLibrary : public NetworkLibrary {
public:
MockNetworkLibrary() {}
virtual ~MockNetworkLibrary() {}
- MOCK_METHOD1(AddObserver, void(Observer*));
- MOCK_METHOD1(RemoveObserver, void(Observer*));
- MOCK_CONST_METHOD0(ethernet_network, const EthernetNetwork&(void));
+ MOCK_METHOD1(AddNetworkManagerObserver, void(NetworkManagerObserver*));
+ MOCK_METHOD1(RemoveNetworkManagerObserver, void(NetworkManagerObserver*));
+ MOCK_METHOD2(AddNetworkObserver, void(const std::string&, NetworkObserver*));
+ MOCK_METHOD2(RemoveNetworkObserver, void(const std::string&,
+ NetworkObserver*));
+ MOCK_METHOD1(RemoveObserverForAllNetworks, void(NetworkObserver*));
+ MOCK_METHOD1(AddCellularDataPlanObserver, void(CellularDataPlanObserver*));
+ MOCK_METHOD1(RemoveCellularDataPlanObserver, void(CellularDataPlanObserver*));
+ MOCK_METHOD0(ethernet_network, EthernetNetwork*(void));
MOCK_CONST_METHOD0(ethernet_connecting, bool(void));
MOCK_CONST_METHOD0(ethernet_connected, bool(void));
- MOCK_CONST_METHOD0(wifi_network, const WifiNetwork&(void));
+ MOCK_METHOD0(wifi_network, WifiNetwork*(void));
MOCK_CONST_METHOD0(wifi_connecting, bool(void));
MOCK_CONST_METHOD0(wifi_connected, bool(void));
- MOCK_CONST_METHOD0(cellular_network, const CellularNetwork&(void));
+ MOCK_METHOD0(cellular_network, CellularNetwork*(void));
MOCK_CONST_METHOD0(cellular_connecting, bool(void));
MOCK_CONST_METHOD0(cellular_connected, bool(void));
@@ -37,33 +43,29 @@ class MockNetworkLibrary : public NetworkLibrary {
MOCK_CONST_METHOD0(wifi_networks, const WifiNetworkVector&(void));
MOCK_CONST_METHOD0(remembered_wifi_networks, const WifiNetworkVector&(void));
MOCK_CONST_METHOD0(cellular_networks, const CellularNetworkVector&(void));
- MOCK_CONST_METHOD0(remembered_cellular_networks,
- const CellularNetworkVector&(void));
- MOCK_CONST_METHOD2(FindWifiNetworkByPath, bool(const std::string&,
- WifiNetwork*));
- MOCK_CONST_METHOD2(FindCellularNetworkByPath, bool(const std::string&,
- CellularNetwork*));
+ MOCK_METHOD1(FindWifiNetworkByPath, WifiNetwork*(const std::string&));
+ MOCK_METHOD1(FindCellularNetworkByPath, CellularNetwork*(const std::string&));
MOCK_METHOD0(RequestWifiScan, void(void));
- MOCK_METHOD0(UpdateSystemInfo, void(void));
MOCK_METHOD1(GetWifiAccessPoints, bool(WifiAccessPointVector*));
- MOCK_METHOD4(ConnectToWifiNetwork, void(WifiNetwork,
+ MOCK_METHOD4(ConnectToWifiNetwork, bool(const WifiNetwork*,
const std::string&,
const std::string&,
const std::string&));
- MOCK_METHOD5(ConnectToWifiNetwork, void(const std::string&,
+ MOCK_METHOD6(ConnectToWifiNetwork, bool(ConnectionSecurity security,
+ const std::string&,
const std::string&,
const std::string&,
const std::string&,
bool));
- MOCK_METHOD1(ConnectToCellularNetwork, void(CellularNetwork));
- MOCK_METHOD1(RefreshCellularDataPlans, void(const CellularNetwork& network));
+ MOCK_METHOD1(ConnectToCellularNetwork, bool(const CellularNetwork*));
+ MOCK_METHOD1(RefreshCellularDataPlans, void(const CellularNetwork* network));
- MOCK_METHOD1(DisconnectFromWirelessNetwork, void(const WirelessNetwork&));
- MOCK_METHOD1(SaveCellularNetwork, void(const CellularNetwork&));
- MOCK_METHOD1(SaveWifiNetwork, void(const WifiNetwork&));
- MOCK_METHOD1(ForgetWirelessNetwork, void(const std::string&));
+ MOCK_METHOD1(DisconnectFromWirelessNetwork, void(const WirelessNetwork*));
+ MOCK_METHOD1(SaveCellularNetwork, void(const CellularNetwork*));
+ MOCK_METHOD1(SaveWifiNetwork, void(const WifiNetwork*));
+ MOCK_METHOD1(ForgetWifiNetwork, void(const std::string&));
MOCK_CONST_METHOD0(ethernet_available, bool(void));
MOCK_CONST_METHOD0(wifi_available, bool(void));
@@ -73,6 +75,7 @@ class MockNetworkLibrary : public NetworkLibrary {
MOCK_CONST_METHOD0(wifi_enabled, bool(void));
MOCK_CONST_METHOD0(cellular_enabled, bool(void));
+ MOCK_CONST_METHOD0(active_network, const Network*(void));
MOCK_CONST_METHOD0(offline_mode, bool(void));
MOCK_METHOD1(EnableEthernetNetworkDevice, void(bool));
diff --git a/chrome/browser/chromeos/cros/mock_update_library.h b/chrome/browser/chromeos/cros/mock_update_library.h
index d4f14cb..1b82342 100644
--- a/chrome/browser/chromeos/cros/mock_update_library.h
+++ b/chrome/browser/chromeos/cros/mock_update_library.h
@@ -20,6 +20,8 @@ class MockUpdateLibrary : public UpdateLibrary {
MOCK_METHOD1(RemoveObserver, void(Observer*)); // NOLINT
MOCK_METHOD0(CheckForUpdate, bool(void));
MOCK_METHOD0(RebootAfterUpdate, bool(void));
+ MOCK_METHOD1(SetReleaseTrack, bool(const std::string&));
+ MOCK_METHOD0(GetReleaseTrack, std::string());
MOCK_CONST_METHOD0(status, const Status&(void));
private:
@@ -29,4 +31,3 @@ class MockUpdateLibrary : public UpdateLibrary {
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_CROS_MOCK_UPDATE_LIBRARY_H_
-
diff --git a/chrome/browser/chromeos/cros/network_library.cc b/chrome/browser/chromeos/cros/network_library.cc
index 896f35c..7e878dd 100644
--- a/chrome/browser/chromeos/cros/network_library.cc
+++ b/chrome/browser/chromeos/cros/network_library.cc
@@ -5,17 +5,145 @@
#include "chrome/browser/chromeos/cros/network_library.h"
#include <algorithm>
+#include <map>
#include "app/l10n_util.h"
+#include "base/stl_util-inl.h"
#include "base/string_number_conversions.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
+#include "base/values.h"
#include "chrome/browser/browser_thread.h"
#include "chrome/browser/chromeos/cros/cros_library.h"
#include "grit/generated_resources.h"
+namespace {
+
+// FlimFlam may send multiple notifications for single network change.
+// We wait small amount of time before retrieving the status to
+// avoid send multiple sync request to flim flam.
+const int kNetworkUpdateDelayMs = 50;
+
+} // namespace
+
namespace chromeos {
+namespace {
+// TODO(ers) These string constants and Parse functions are copied
+// straight out of libcros:chromeos_network.cc. Fix this by moving
+// all handling of properties into libcros.
+// Network service properties we are interested in monitoring
+static const char* kIsActiveProperty = "IsActive";
+static const char* kStateProperty = "State";
+static const char* kSignalStrengthProperty = "Strength";
+static const char* kActivationStateProperty = "Cellular.ActivationState";
+static const char* kNetworkTechnologyProperty = "Cellular.NetworkTechnology";
+static const char* kPaymentURLProperty = "Cellular.OlpUrl";
+static const char* kRestrictedPoolProperty = "Cellular.RestrictedPool";
+static const char* kRoamingStateProperty = "Cellular.RoamingState";
+
+// Connman state options.
+static const char* kStateIdle = "idle";
+static const char* kStateCarrier = "carrier";
+static const char* kStateAssociation = "association";
+static const char* kStateConfiguration = "configuration";
+static const char* kStateReady = "ready";
+static const char* kStateDisconnect = "disconnect";
+static const char* kStateFailure = "failure";
+static const char* kStateActivationFailure = "activation-failure";
+
+// Connman activation state options
+static const char* kActivationStateActivated = "activated";
+static const char* kActivationStateActivating = "activating";
+static const char* kActivationStateNotActivated = "not-activated";
+static const char* kActivationStatePartiallyActivated = "partially-activated";
+static const char* kActivationStateUnknown = "unknown";
+
+// Connman network technology options.
+static const char* kNetworkTechnology1Xrtt = "1xRTT";
+static const char* kNetworkTechnologyEvdo = "EVDO";
+static const char* kNetworkTechnologyGprs = "GPRS";
+static const char* kNetworkTechnologyEdge = "EDGE";
+static const char* kNetworkTechnologyUmts = "UMTS";
+static const char* kNetworkTechnologyHspa = "HSPA";
+static const char* kNetworkTechnologyHspaPlus = "HSPA+";
+static const char* kNetworkTechnologyLte = "LTE";
+static const char* kNetworkTechnologyLteAdvanced = "LTE Advanced";
+
+// Connman roaming state options
+static const char* kRoamingStateHome = "home";
+static const char* kRoamingStateRoaming = "roaming";
+static const char* kRoamingStateUnknown = "unknown";
+
+static ConnectionState ParseState(const std::string& state) {
+ if (state == kStateIdle)
+ return STATE_IDLE;
+ if (state == kStateCarrier)
+ return STATE_CARRIER;
+ if (state == kStateAssociation)
+ return STATE_ASSOCIATION;
+ if (state == kStateConfiguration)
+ return STATE_CONFIGURATION;
+ if (state == kStateReady)
+ return STATE_READY;
+ if (state == kStateDisconnect)
+ return STATE_DISCONNECT;
+ if (state == kStateFailure)
+ return STATE_FAILURE;
+ if (state == kStateActivationFailure)
+ return STATE_ACTIVATION_FAILURE;
+ return STATE_UNKNOWN;
+}
+
+static ActivationState ParseActivationState(
+ const std::string& activation_state) {
+ if (activation_state == kActivationStateActivated)
+ return ACTIVATION_STATE_ACTIVATED;
+ if (activation_state == kActivationStateActivating)
+ return ACTIVATION_STATE_ACTIVATING;
+ if (activation_state == kActivationStateNotActivated)
+ return ACTIVATION_STATE_NOT_ACTIVATED;
+ if (activation_state == kActivationStateUnknown)
+ return ACTIVATION_STATE_UNKNOWN;
+ if (activation_state == kActivationStatePartiallyActivated)
+ return ACTIVATION_STATE_PARTIALLY_ACTIVATED;
+ return ACTIVATION_STATE_UNKNOWN;
+}
+
+static NetworkTechnology ParseNetworkTechnology(
+ const std::string& technology) {
+ if (technology == kNetworkTechnology1Xrtt)
+ return NETWORK_TECHNOLOGY_1XRTT;
+ if (technology == kNetworkTechnologyEvdo)
+ return NETWORK_TECHNOLOGY_EVDO;
+ if (technology == kNetworkTechnologyGprs)
+ return NETWORK_TECHNOLOGY_GPRS;
+ if (technology == kNetworkTechnologyEdge)
+ return NETWORK_TECHNOLOGY_EDGE;
+ if (technology == kNetworkTechnologyUmts)
+ return NETWORK_TECHNOLOGY_UMTS;
+ if (technology == kNetworkTechnologyHspa)
+ return NETWORK_TECHNOLOGY_HSPA;
+ if (technology == kNetworkTechnologyHspaPlus)
+ return NETWORK_TECHNOLOGY_HSPA_PLUS;
+ if (technology == kNetworkTechnologyLte)
+ return NETWORK_TECHNOLOGY_LTE;
+ if (technology == kNetworkTechnologyLteAdvanced)
+ return NETWORK_TECHNOLOGY_LTE_ADVANCED;
+ return NETWORK_TECHNOLOGY_UNKNOWN;
+}
+static NetworkRoamingState ParseRoamingState(
+ const std::string& roaming_state) {
+ if (roaming_state == kRoamingStateHome)
+ return ROAMING_STATE_HOME;
+ if (roaming_state == kRoamingStateRoaming)
+ return ROAMING_STATE_ROAMING;
+ if (roaming_state == kRoamingStateUnknown)
+ return ROAMING_STATE_UNKNOWN;
+ return ROAMING_STATE_UNKNOWN;
+}
+}
+
// Helper function to wrap Html with <th> tag.
static std::string WrapWithTH(std::string text) {
return "<th>" + text + "</th>";
@@ -82,24 +210,35 @@ static bool EnsureCrosLoaded() {
////////////////////////////////////////////////////////////////////////////////
// Network
+Network::Network(const Network& network) {
+ service_path_ = network.service_path();
+ device_path_ = network.device_path();
+ ip_address_ = network.ip_address();
+ type_ = network.type();
+ state_ = network.state();
+ error_ = network.error();
+}
+
void Network::Clear() {
state_ = STATE_UNKNOWN;
error_ = ERROR_UNKNOWN;
service_path_.clear();
device_path_.clear();
ip_address_.clear();
+ is_active_ = false;
}
-void Network::ConfigureFromService(const ServiceInfo& service) {
- type_ = service.type;
- state_ = service.state;
- error_ = service.error;
- service_path_ = SafeString(service.service_path);
- device_path_ = SafeString(service.device_path);
+Network::Network(const ServiceInfo* service) {
+ type_ = service->type;
+ state_ = service->state;
+ error_ = service->error;
+ service_path_ = SafeString(service->service_path);
+ device_path_ = SafeString(service->device_path);
+ is_active_ = service->is_active;
ip_address_.clear();
// If connected, get ip config.
- if (EnsureCrosLoaded() && connected() && service.device_path) {
- IPConfigStatus* ipconfig_status = ListIPConfigs(service.device_path);
+ if (EnsureCrosLoaded() && connected() && service->device_path) {
+ IPConfigStatus* ipconfig_status = ListIPConfigs(service->device_path);
if (ipconfig_status) {
for (int i = 0; i < ipconfig_status->size; i++) {
IPConfig ipconfig = ipconfig_status->ips[i];
@@ -179,6 +318,21 @@ std::string Network::GetErrorString() const {
////////////////////////////////////////////////////////////////////////////////
// WirelessNetwork
+WirelessNetwork::WirelessNetwork(const WirelessNetwork& network)
+ : Network(network) {
+ name_ = network.name();
+ strength_ = network.strength();
+ auto_connect_ = network.auto_connect();
+ favorite_ = network.favorite();
+}
+
+WirelessNetwork::WirelessNetwork(const ServiceInfo* service)
+ : Network(service) {
+ name_ = SafeString(service->name);
+ strength_ = service->strength;
+ auto_connect_ = service->auto_connect;
+ favorite_ = service->favorite;
+}
void WirelessNetwork::Clear() {
Network::Clear();
@@ -188,14 +342,6 @@ void WirelessNetwork::Clear() {
favorite_ = false;
}
-void WirelessNetwork::ConfigureFromService(const ServiceInfo& service) {
- Network::ConfigureFromService(service);
- name_ = SafeString(service.name);
- strength_ = service.strength;
- auto_connect_ = service.auto_connect;
- favorite_ = service.favorite;
-}
-
////////////////////////////////////////////////////////////////////////////////
// CellularNetwork
@@ -210,6 +356,65 @@ CellularNetwork::CellularNetwork()
type_ = TYPE_CELLULAR;
}
+CellularNetwork::CellularNetwork(const CellularNetwork& network)
+ : WirelessNetwork(network) {
+ activation_state_ = network.activation_state();
+ network_technology_ = network.network_technology();
+ roaming_state_ = network.roaming_state();
+ restricted_pool_ = network.restricted_pool();
+ service_name_ = network.service_name();
+ operator_name_ = network.operator_name();
+ operator_code_ = network.operator_code();
+ payment_url_ = network.payment_url();
+ meid_ = network.meid();
+ imei_ = network.imei();
+ imsi_ = network.imsi();
+ esn_ = network.esn();
+ mdn_ = network.mdn();
+ min_ = network.min();
+ model_id_ = network.model_id();
+ manufacturer_ = network.manufacturer();
+ firmware_revision_ = network.firmware_revision();
+ hardware_revision_ = network.hardware_revision();
+ last_update_ = network.last_update();
+ prl_version_ = network.prl_version();
+ type_ = TYPE_CELLULAR;
+}
+
+CellularNetwork::CellularNetwork(const ServiceInfo* service)
+ : WirelessNetwork(service) {
+ service_name_ = SafeString(service->name);
+ activation_state_ = service->activation_state;
+ network_technology_ = service->network_technology;
+ roaming_state_ = service->roaming_state;
+ restricted_pool_ = service->restricted_pool;
+ // Carrier Info
+ if (service->carrier_info) {
+ operator_name_ = SafeString(service->carrier_info->operator_name);
+ operator_code_ = SafeString(service->carrier_info->operator_code);
+ payment_url_ = SafeString(service->carrier_info->payment_url);
+ }
+ // Device Info
+ if (service->device_info) {
+ meid_ = SafeString(service->device_info->MEID);
+ imei_ = SafeString(service->device_info->IMEI);
+ imsi_ = SafeString(service->device_info->IMSI);
+ esn_ = SafeString(service->device_info->ESN);
+ mdn_ = SafeString(service->device_info->MDN);
+ min_ = SafeString(service->device_info->MIN);
+ model_id_ = SafeString(service->device_info->model_id);
+ manufacturer_ = SafeString(service->device_info->manufacturer);
+ firmware_revision_ = SafeString(service->device_info->firmware_revision);
+ hardware_revision_ = SafeString(service->device_info->hardware_revision);
+ last_update_ = SafeString(service->device_info->last_update);
+ prl_version_ = service->device_info->PRL_version;
+ }
+ type_ = TYPE_CELLULAR;
+}
+
+CellularNetwork::~CellularNetwork() {
+}
+
bool CellularNetwork::StartActivation() const {
if (!EnsureCrosLoaded())
return false;
@@ -240,36 +445,6 @@ void CellularNetwork::Clear() {
prl_version_ = 0;
}
-void CellularNetwork::ConfigureFromService(const ServiceInfo& service) {
- WirelessNetwork::ConfigureFromService(service);
- service_name_ = SafeString(service.name);
- activation_state_ = service.activation_state;
- network_technology_ = service.network_technology;
- roaming_state_ = service.roaming_state;
- restricted_pool_ = service.restricted_pool;
- // Carrier Info
- if (service.carrier_info) {
- operator_name_ = SafeString(service.carrier_info->operator_name);
- operator_code_ = SafeString(service.carrier_info->operator_code);
- payment_url_ = SafeString(service.carrier_info->payment_url);
- }
- // Device Info
- if (service.device_info) {
- meid_ = SafeString(service.device_info->MEID);
- imei_ = SafeString(service.device_info->IMEI);
- imsi_ = SafeString(service.device_info->IMSI);
- esn_ = SafeString(service.device_info->ESN);
- mdn_ = SafeString(service.device_info->MDN);
- min_ = SafeString(service.device_info->MIN);
- model_id_ = SafeString(service.device_info->model_id);
- manufacturer_ = SafeString(service.device_info->manufacturer);
- firmware_revision_ = SafeString(service.device_info->firmware_revision);
- hardware_revision_ = SafeString(service.device_info->hardware_revision);
- last_update_ = SafeString(service.device_info->last_update);
- prl_version_ = service.device_info->PRL_version;
- }
-}
-
bool CellularNetwork::is_gsm() const {
return network_technology_ != NETWORK_TECHNOLOGY_EVDO &&
network_technology_ != NETWORK_TECHNOLOGY_1XRTT &&
@@ -279,14 +454,15 @@ bool CellularNetwork::is_gsm() const {
CellularNetwork::DataLeft CellularNetwork::data_left() const {
if (data_plans_.empty())
return DATA_NORMAL;
- CellularDataPlan plan = data_plans_[0];
+ const CellularDataPlan& plan(data_plans_[0]);
if (plan.plan_type == CELLULAR_DATA_PLAN_UNLIMITED) {
- int64 remaining = plan.plan_end_time - plan.update_time;
- if (remaining <= 0)
+ base::TimeDelta remaining = plan.plan_end_time - plan.update_time;
+ if (remaining <= base::TimeDelta::FromSeconds(0))
return DATA_NONE;
- else if (remaining <= kCellularDataVeryLowSecs)
+ else if (remaining <=
+ base::TimeDelta::FromSeconds(kCellularDataVeryLowSecs))
return DATA_VERY_LOW;
- else if (remaining <= kCellularDataLowSecs)
+ else if (remaining <= base::TimeDelta::FromSeconds(kCellularDataLowSecs))
return DATA_LOW;
else
return DATA_NORMAL;
@@ -342,8 +518,9 @@ std::string CellularNetwork::GetNetworkTechnologyString() const {
}
}
-std::string CellularNetwork::GetActivationStateString() const {
- switch (this->activation_state_) {
+std::string CellularNetwork::ActivationStateToString(
+ ActivationState activation_state) {
+ switch (activation_state) {
case ACTIVATION_STATE_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATED);
@@ -367,6 +544,10 @@ std::string CellularNetwork::GetActivationStateString() const {
}
}
+std::string CellularNetwork::GetActivationStateString() const {
+ return ActivationStateToString(this->activation_state_);
+}
+
std::string CellularNetwork::GetRoamingStateString() const {
switch (this->roaming_state_) {
case ROAMING_STATE_HOME:
@@ -394,8 +575,28 @@ WifiNetwork::WifiNetwork()
type_ = TYPE_WIFI;
}
-WifiNetwork::WifiNetwork(const ServiceInfo& service) : WirelessNetwork() {
- ConfigureFromService(service);
+WifiNetwork::WifiNetwork(const WifiNetwork& network)
+ : WirelessNetwork(network) {
+ encryption_ = network.encryption();
+ passphrase_ = network.passphrase();
+ passphrase_required_ = network.passphrase_required();
+ identity_ = network.identity();
+ cert_path_ = network.cert_path();
+}
+
+WifiNetwork::WifiNetwork(const ServiceInfo* service)
+ : WirelessNetwork(service) {
+ encryption_ = service->security;
+ passphrase_ = SafeString(service->passphrase);
+ // TODO(stevenjb): Remove this once flimflam is setting passphrase_required
+ // correctly: http://crosbug.com/8830.
+ if (service->state == chromeos::STATE_FAILURE &&
+ service->security != chromeos::SECURITY_NONE)
+ passphrase_required_ = true;
+ else
+ passphrase_required_ = service->passphrase_required;
+ identity_ = SafeString(service->identity);
+ cert_path_ = SafeString(service->cert_path);
type_ = TYPE_WIFI;
}
@@ -407,14 +608,6 @@ void WifiNetwork::Clear() {
cert_path_.clear();
}
-void WifiNetwork::ConfigureFromService(const ServiceInfo& service) {
- WirelessNetwork::ConfigureFromService(service);
- encryption_ = service.security;
- passphrase_ = SafeString(service.passphrase);
- identity_ = SafeString(service.identity);
- cert_path_ = SafeString(service.cert_path);
-}
-
std::string WifiNetwork::GetEncryptionString() {
switch (encryption_) {
case SECURITY_UNKNOWN:
@@ -457,47 +650,145 @@ bool WifiNetwork::IsCertificateLoaded() const {
class NetworkLibraryImpl : public NetworkLibrary {
public:
NetworkLibraryImpl()
- : network_status_connection_(NULL),
+ : network_manager_monitor_(NULL),
data_plan_monitor_(NULL),
+ ethernet_(NULL),
+ wifi_(NULL),
+ cellular_(NULL),
available_devices_(0),
enabled_devices_(0),
connected_devices_(0),
- offline_mode_(false) {
+ offline_mode_(false),
+ update_task_(NULL) {
if (EnsureCrosLoaded()) {
Init();
+ network_manager_monitor_ =
+ MonitorNetworkManager(&NetworkManagerStatusChangedHandler,
+ this);
+ data_plan_monitor_ = MonitorCellularDataPlan(&DataPlanUpdateHandler,
+ this);
} else {
InitTestData();
}
}
~NetworkLibraryImpl() {
- if (network_status_connection_) {
- DisconnectMonitorNetwork(network_status_connection_);
- }
- if (data_plan_monitor_) {
+ network_manager_observers_.Clear();
+ if (network_manager_monitor_)
+ DisconnectPropertyChangeMonitor(network_manager_monitor_);
+ data_plan_observers_.Clear();
+ if (data_plan_monitor_)
DisconnectDataPlanUpdateMonitor(data_plan_monitor_);
+ STLDeleteValues(&network_observers_);
+ ClearNetworks();
+ }
+
+ virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {
+ if (!network_manager_observers_.HasObserver(observer))
+ network_manager_observers_.AddObserver(observer);
+ }
+
+ void NetworkStatusChanged() {
+ CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ if (update_task_) {
+ update_task_->Cancel();
+ }
+ update_task_ =
+ NewRunnableMethod(this,
+ &NetworkLibraryImpl::UpdateNetworkManagerStatus);
+ BrowserThread::PostDelayedTask(
+ BrowserThread::UI, FROM_HERE, update_task_,
+ kNetworkUpdateDelayMs);
+ }
+
+ virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {
+ network_manager_observers_.RemoveObserver(observer);
+ }
+
+ virtual void AddNetworkObserver(const std::string& service_path,
+ NetworkObserver* observer) {
+ DCHECK(observer);
+ if (!EnsureCrosLoaded())
+ return;
+ // First, add the observer to the callback map.
+ NetworkObserverMap::iterator iter = network_observers_.find(service_path);
+ NetworkObserverList* oblist;
+ if (iter != network_observers_.end()) {
+ oblist = iter->second;
+ } else {
+ std::pair<NetworkObserverMap::iterator, bool> inserted =
+ network_observers_.insert(
+ std::make_pair<std::string, NetworkObserverList*>(
+ service_path,
+ new NetworkObserverList(this, service_path)));
+ oblist = inserted.first->second;
+ }
+ if (!oblist->HasObserver(observer))
+ oblist->AddObserver(observer);
+ }
+
+ virtual void RemoveNetworkObserver(const std::string& service_path,
+ NetworkObserver* observer) {
+ DCHECK(observer);
+ DCHECK(service_path.size());
+ NetworkObserverMap::iterator map_iter =
+ network_observers_.find(service_path);
+ if (map_iter != network_observers_.end()) {
+ map_iter->second->RemoveObserver(observer);
+ if (!map_iter->second->size()) {
+ delete map_iter->second;
+ network_observers_.erase(map_iter++);
+ }
}
}
- void AddObserver(Observer* observer) {
- observers_.AddObserver(observer);
+ virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {
+ DCHECK(observer);
+ NetworkObserverMap::iterator map_iter = network_observers_.begin();
+ while (map_iter != network_observers_.end()) {
+ map_iter->second->RemoveObserver(observer);
+ if (!map_iter->second->size()) {
+ delete map_iter->second;
+ network_observers_.erase(map_iter++);
+ } else {
+ ++map_iter;
+ }
+ }
}
- void RemoveObserver(Observer* observer) {
- observers_.RemoveObserver(observer);
+ virtual void AddCellularDataPlanObserver(CellularDataPlanObserver* observer) {
+ if (!data_plan_observers_.HasObserver(observer))
+ data_plan_observers_.AddObserver(observer);
}
- virtual const EthernetNetwork& ethernet_network() const { return ethernet_; }
- virtual bool ethernet_connecting() const { return ethernet_.connecting(); }
- virtual bool ethernet_connected() const { return ethernet_.connected(); }
+ virtual void RemoveCellularDataPlanObserver(
+ CellularDataPlanObserver* observer) {
+ data_plan_observers_.RemoveObserver(observer);
+ }
- virtual const WifiNetwork& wifi_network() const { return wifi_; }
- virtual bool wifi_connecting() const { return wifi_.connecting(); }
- virtual bool wifi_connected() const { return wifi_.connected(); }
+ virtual EthernetNetwork* ethernet_network() { return ethernet_; }
+ virtual bool ethernet_connecting() const {
+ return ethernet_ ? ethernet_->connecting() : false;
+ }
+ virtual bool ethernet_connected() const {
+ return ethernet_ ? ethernet_->connected() : false;
+ }
- virtual const CellularNetwork& cellular_network() const { return cellular_; }
- virtual bool cellular_connecting() const { return cellular_.connecting(); }
- virtual bool cellular_connected() const { return cellular_.connected(); }
+ virtual WifiNetwork* wifi_network() { return wifi_; }
+ virtual bool wifi_connecting() const {
+ return wifi_ ? wifi_->connecting() : false;
+ }
+ virtual bool wifi_connected() const {
+ return wifi_ ? wifi_->connected() : false;
+ }
+
+ virtual CellularNetwork* cellular_network() { return cellular_; }
+ virtual bool cellular_connecting() const {
+ return cellular_ ? cellular_->connecting() : false;
+ }
+ virtual bool cellular_connected() const {
+ return cellular_ ? cellular_->connected() : false;
+ }
bool Connected() const {
return ethernet_connected() || wifi_connected() || cellular_connected();
@@ -508,14 +799,14 @@ class NetworkLibraryImpl : public NetworkLibrary {
}
const std::string& IPAddress() const {
- // Returns highest priority IP address.
- if (ethernet_connected())
- return ethernet_.ip_address();
- if (wifi_connected())
- return wifi_.ip_address();
- if (cellular_connected())
- return cellular_.ip_address();
- return ethernet_.ip_address();
+ // Returns IP address for the active network.
+ const Network* active = active_network();
+ if (active != NULL)
+ return active->ip_address();
+ if (ethernet_)
+ return ethernet_->ip_address();
+ static std::string null_address("0.0.0.0");
+ return null_address;
}
virtual const WifiNetworkVector& wifi_networks() const {
@@ -530,34 +821,16 @@ class NetworkLibraryImpl : public NetworkLibrary {
return cellular_networks_;
}
- virtual const CellularNetworkVector& remembered_cellular_networks() const {
- return remembered_cellular_networks_;
- }
-
/////////////////////////////////////////////////////////////////////////////
- virtual bool FindWifiNetworkByPath(
- const std::string& path, WifiNetwork* result) const {
- const WifiNetwork* wifi =
- GetWirelessNetworkByPath(wifi_networks_, path);
- if (wifi) {
- if (result)
- *result = *wifi;
- return true;
- }
- return false;
+ virtual WifiNetwork* FindWifiNetworkByPath(
+ const std::string& path) {
+ return GetWirelessNetworkByPath(wifi_networks_, path);
}
- virtual bool FindCellularNetworkByPath(
- const std::string& path, CellularNetwork* result) const {
- const CellularNetwork* cellular =
- GetWirelessNetworkByPath(cellular_networks_, path);
- if (cellular) {
- if (result)
- *result = *cellular;
- return true;
- }
- return false;
+ virtual CellularNetwork* FindCellularNetworkByPath(
+ const std::string& path) {
+ return GetWirelessNetworkByPath(cellular_networks_, path);
}
virtual void RequestWifiScan() {
@@ -591,148 +864,158 @@ class NetworkLibraryImpl : public NetworkLibrary {
return true;
}
- virtual void ConnectToWifiNetwork(WifiNetwork network,
+ virtual bool ConnectToWifiNetwork(const WifiNetwork* network,
const std::string& password,
const std::string& identity,
const std::string& certpath) {
- if (EnsureCrosLoaded()) {
- if (ConnectToNetworkWithCertInfo(network.service_path().c_str(),
- password.empty() ? NULL : password.c_str(),
- identity.empty() ? NULL : identity.c_str(),
- certpath.empty() ? NULL : certpath.c_str())) {
- // Update local cache and notify listeners.
- WifiNetwork* wifi = GetWirelessNetworkByPath(
- wifi_networks_, network.service_path());
- if (wifi) {
- wifi->set_passphrase(password);
- wifi->set_identity(identity);
- wifi->set_cert_path(certpath);
- wifi->set_connecting(true);
- wifi_ = *wifi;
- }
- NotifyNetworkChanged();
+ DCHECK(network);
+ if (!EnsureCrosLoaded())
+ return true; // No library loaded, don't trigger a retry attempt.
+ // TODO(ers) make wifi the highest priority service type
+ if (ConnectToNetworkWithCertInfo(network->service_path().c_str(),
+ password.empty() ? NULL : password.c_str(),
+ identity.empty() ? NULL : identity.c_str(),
+ certpath.empty() ? NULL : certpath.c_str())) {
+ // Update local cache and notify listeners.
+ WifiNetwork* wifi = GetWirelessNetworkByPath(
+ wifi_networks_, network->service_path());
+ if (wifi) {
+ wifi->set_passphrase(password);
+ wifi->set_identity(identity);
+ wifi->set_cert_path(certpath);
+ wifi->set_connecting(true);
+ wifi_ = wifi;
}
+ NotifyNetworkManagerChanged();
+ return true;
+ } else {
+ return false; // Immediate failure.
}
}
- virtual void ConnectToWifiNetwork(const std::string& ssid,
+ virtual bool ConnectToWifiNetwork(ConnectionSecurity security,
+ const std::string& ssid,
const std::string& password,
const std::string& identity,
const std::string& certpath,
bool auto_connect) {
- if (EnsureCrosLoaded()) {
- // First create a service from hidden network.
- ServiceInfo* service = GetWifiService(ssid.c_str(),
- SECURITY_UNKNOWN);
- if (service) {
- // Set auto-connect.
- SetAutoConnect(service->service_path, auto_connect);
- // Now connect to that service.
- ConnectToNetworkWithCertInfo(service->service_path,
- password.empty() ? NULL : password.c_str(),
- identity.empty() ? NULL : identity.c_str(),
- certpath.empty() ? NULL : certpath.c_str());
-
- // Clean up ServiceInfo object.
- FreeServiceInfo(service);
- } else {
- LOG(WARNING) << "Cannot find hidden network: " << ssid;
- // TODO(chocobo): Show error message.
- }
+ if (!EnsureCrosLoaded())
+ return true; // No library loaded, don't trigger a retry attempt.
+ // First create a service from hidden network.
+ ServiceInfo* service = GetWifiService(ssid.c_str(), security);
+ if (service) {
+ // Set auto-connect.
+ SetAutoConnect(service->service_path, auto_connect);
+ // Now connect to that service.
+ // TODO(ers) make wifi the highest priority service type
+ bool res = ConnectToNetworkWithCertInfo(
+ service->service_path,
+ password.empty() ? NULL : password.c_str(),
+ identity.empty() ? NULL : identity.c_str(),
+ certpath.empty() ? NULL : certpath.c_str());
+
+ // Clean up ServiceInfo object.
+ FreeServiceInfo(service);
+ return res;
+ } else {
+ LOG(WARNING) << "Cannot find hidden network: " << ssid;
+ // TODO(chocobo): Show error message.
+ return false; // Immediate failure.
}
}
- virtual void ConnectToCellularNetwork(CellularNetwork network) {
- if (EnsureCrosLoaded()) {
- if (ConnectToNetwork(network.service_path().c_str(), NULL)) {
- // Update local cache and notify listeners.
- CellularNetwork* cellular = GetWirelessNetworkByPath(
- cellular_networks_, network.service_path());
- if (cellular) {
- cellular->set_connecting(true);
- cellular_ = *cellular;
- }
- NotifyNetworkChanged();
+ virtual bool ConnectToCellularNetwork(const CellularNetwork* network) {
+ DCHECK(network);
+ if (!EnsureCrosLoaded())
+ return true; // No library loaded, don't trigger a retry attempt.
+ // TODO(ers) make cellular the highest priority service type
+ if (network && ConnectToNetwork(network->service_path().c_str(), NULL)) {
+ // Update local cache and notify listeners.
+ CellularNetwork* cellular = GetWirelessNetworkByPath(
+ cellular_networks_, network->service_path());
+ if (cellular) {
+ cellular->set_connecting(true);
+ cellular_ = cellular;
}
+ NotifyNetworkManagerChanged();
+ return true;
+ } else {
+ return false; // Immediate failure.
}
}
- virtual void RefreshCellularDataPlans(const CellularNetwork& network) {
- if (!EnsureCrosLoaded())
+ virtual void RefreshCellularDataPlans(const CellularNetwork* network) {
+ DCHECK(network);
+ if (!EnsureCrosLoaded() || !network)
return;
- RequestCellularDataPlanUpdate(network.service_path().c_str());
+ RequestCellularDataPlanUpdate(network->service_path().c_str());
}
- virtual void DisconnectFromWirelessNetwork(const WirelessNetwork& network) {
- if (EnsureCrosLoaded()) {
- if (DisconnectFromNetwork(network.service_path().c_str())) {
- // Update local cache and notify listeners.
- if (network.type() == TYPE_WIFI) {
- WifiNetwork* wifi = GetWirelessNetworkByPath(
- wifi_networks_, network.service_path());
- if (wifi) {
- wifi->set_connected(false);
- wifi_ = WifiNetwork();
- }
- } else if (network.type() == TYPE_CELLULAR) {
- CellularNetwork* cellular = GetWirelessNetworkByPath(
- cellular_networks_, network.service_path());
- if (cellular) {
- cellular->set_connected(false);
- cellular_ = CellularNetwork();
- }
+ virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {
+ DCHECK(network);
+ if (!EnsureCrosLoaded() || !network)
+ return;
+ // TODO(ers) restore default service type priority ordering?
+ if (DisconnectFromNetwork(network->service_path().c_str())) {
+ // Update local cache and notify listeners.
+ if (network->type() == TYPE_WIFI) {
+ WifiNetwork* wifi = GetWirelessNetworkByPath(
+ wifi_networks_, network->service_path());
+ if (wifi) {
+ wifi->set_connected(false);
+ wifi_ = NULL;
+ }
+ } else if (network->type() == TYPE_CELLULAR) {
+ CellularNetwork* cellular = GetWirelessNetworkByPath(
+ cellular_networks_, network->service_path());
+ if (cellular) {
+ cellular->set_connected(false);
+ cellular_ = NULL;
}
- NotifyNetworkChanged();
}
+ NotifyNetworkManagerChanged();
}
}
- virtual void SaveCellularNetwork(const CellularNetwork& network) {
- // Update the wifi network in the local cache.
- CellularNetwork* cellular = GetWirelessNetworkByPath(
- cellular_networks_, network.service_path());
- if (cellular)
- *cellular = network;
-
+ virtual void SaveCellularNetwork(const CellularNetwork* network) {
+ DCHECK(network);
// Update the cellular network with libcros.
- if (EnsureCrosLoaded()) {
- SetAutoConnect(network.service_path().c_str(), network.auto_connect());
- }
- }
+ if (!EnsureCrosLoaded() || !network)
+ return;
- virtual void SaveWifiNetwork(const WifiNetwork& network) {
- // Update the wifi network in the local cache.
- WifiNetwork* wifi = GetWirelessNetworkByPath(
- wifi_networks_, network.service_path());
- if (wifi)
- *wifi = network;
+ SetAutoConnect(network->service_path().c_str(), network->auto_connect());
+ }
+ virtual void SaveWifiNetwork(const WifiNetwork* network) {
+ DCHECK(network);
// Update the wifi network with libcros.
- if (EnsureCrosLoaded()) {
- SetPassphrase(
- network.service_path().c_str(), network.passphrase().c_str());
- SetIdentity(network.service_path().c_str(), network.identity().c_str());
- SetCertPath(network.service_path().c_str(), network.cert_path().c_str());
- SetAutoConnect(network.service_path().c_str(), network.auto_connect());
- }
+ if (!EnsureCrosLoaded() || !network)
+ return;
+ SetPassphrase(
+ network->service_path().c_str(), network->passphrase().c_str());
+ SetIdentity(network->service_path().c_str(),
+ network->identity().c_str());
+ SetCertPath(network->service_path().c_str(),
+ network->cert_path().c_str());
+ SetAutoConnect(network->service_path().c_str(), network->auto_connect());
}
- virtual void ForgetWirelessNetwork(const std::string& service_path) {
- if (EnsureCrosLoaded()) {
- if (DeleteRememberedService(service_path.c_str())) {
- // Update local cache and notify listeners.
- remembered_wifi_networks_.erase(
- std::remove_if(remembered_wifi_networks_.begin(),
- remembered_wifi_networks_.end(),
- WirelessNetwork::ServicePathEq(service_path)),
- remembered_wifi_networks_.end());
- remembered_cellular_networks_.erase(
- std::remove_if(remembered_cellular_networks_.begin(),
- remembered_cellular_networks_.end(),
- WirelessNetwork::ServicePathEq(service_path)),
- remembered_cellular_networks_.end());
- NotifyNetworkChanged();
+ virtual void ForgetWifiNetwork(const std::string& service_path) {
+ if (!EnsureCrosLoaded())
+ return;
+ if (DeleteRememberedService(service_path.c_str())) {
+ // Update local cache and notify listeners.
+ for (WifiNetworkVector::iterator iter =
+ remembered_wifi_networks_.begin();
+ iter != remembered_wifi_networks_.end();
+ ++iter) {
+ if ((*iter)->service_path() == service_path) {
+ delete (*iter);
+ remembered_wifi_networks_.erase(iter);
+ break;
+ }
}
+ NotifyNetworkManagerChanged();
}
}
@@ -758,6 +1041,16 @@ class NetworkLibraryImpl : public NetworkLibrary {
virtual bool offline_mode() const { return offline_mode_; }
+ virtual const Network* active_network() const {
+ if (ethernet_ && ethernet_->is_active())
+ return ethernet_;
+ if (wifi_ && wifi_->is_active())
+ return wifi_;
+ if (cellular_ && cellular_->is_active())
+ return cellular_;
+ return NULL;
+ }
+
virtual void EnableEthernetNetworkDevice(bool enable) {
EnableNetworkDeviceType(TYPE_ETHERNET, enable);
}
@@ -776,12 +1069,11 @@ class NetworkLibraryImpl : public NetworkLibrary {
// If network device is already enabled/disabled, then don't do anything.
if (enable && offline_mode_) {
- LOG(INFO) << "Trying to enable offline mode when it's already enabled. ";
+ VLOG(1) << "Trying to enable offline mode when it's already enabled.";
return;
}
if (!enable && !offline_mode_) {
- LOG(INFO) <<
- "Trying to disable offline mode when it's already disabled. ";
+ VLOG(1) << "Trying to disable offline mode when it's already disabled.";
return;
}
@@ -828,42 +1120,33 @@ class NetworkLibraryImpl : public NetworkLibrary {
}
output.append("<h3>Ethernet:</h3><table border=1>");
- if (ethernet_enabled()) {
- output.append("<tr>" + ToHtmlTableHeader(&ethernet_) + "</tr>");
- output.append("<tr>" + ToHtmlTableRow(&ethernet_) + "</tr>");
+ if (ethernet_ && ethernet_enabled()) {
+ output.append("<tr>" + ToHtmlTableHeader(ethernet_) + "</tr>");
+ output.append("<tr>" + ToHtmlTableRow(ethernet_) + "</tr>");
}
output.append("</table><h3>Wifi:</h3><table border=1>");
for (size_t i = 0; i < wifi_networks_.size(); ++i) {
if (i == 0)
- output.append("<tr>" + ToHtmlTableHeader(&wifi_networks_[i]) + "</tr>");
- output.append("<tr>" + ToHtmlTableRow(&wifi_networks_[i]) + "</tr>");
+ output.append("<tr>" + ToHtmlTableHeader(wifi_networks_[i]) + "</tr>");
+ output.append("<tr>" + ToHtmlTableRow(wifi_networks_[i]) + "</tr>");
}
output.append("</table><h3>Cellular:</h3><table border=1>");
for (size_t i = 0; i < cellular_networks_.size(); ++i) {
if (i == 0)
- output.append("<tr>" + ToHtmlTableHeader(&cellular_networks_[i]) +
+ output.append("<tr>" + ToHtmlTableHeader(cellular_networks_[i]) +
"</tr>");
- output.append("<tr>" + ToHtmlTableRow(&cellular_networks_[i]) + "</tr>");
+ output.append("<tr>" + ToHtmlTableRow(cellular_networks_[i]) + "</tr>");
}
output.append("</table><h3>Remembered Wifi:</h3><table border=1>");
for (size_t i = 0; i < remembered_wifi_networks_.size(); ++i) {
if (i == 0)
output.append(
- "<tr>" + ToHtmlTableHeader(&remembered_wifi_networks_[i]) +
+ "<tr>" + ToHtmlTableHeader(remembered_wifi_networks_[i]) +
"</tr>");
- output.append("<tr>" + ToHtmlTableRow(&remembered_wifi_networks_[i]) +
- "</tr>");
- }
-
- output.append("</table><h3>Remembered Cellular:</h3><table border=1>");
- for (size_t i = 0; i < remembered_cellular_networks_.size(); ++i) {
- if (i == 0)
- output.append("<tr>" +
- ToHtmlTableHeader(&remembered_cellular_networks_[i]) + "</tr>");
- output.append("<tr>" + ToHtmlTableRow(&remembered_cellular_networks_[i]) +
+ output.append("<tr>" + ToHtmlTableRow(remembered_wifi_networks_[i]) +
"</tr>");
}
@@ -872,157 +1155,175 @@ class NetworkLibraryImpl : public NetworkLibrary {
}
private:
- static void NetworkStatusChangedHandler(void* object) {
- NetworkLibraryImpl* network = static_cast<NetworkLibraryImpl*>(object);
- DCHECK(network);
- network->UpdateNetworkStatus();
+
+ class NetworkObserverList : public ObserverList<NetworkObserver> {
+ public:
+ NetworkObserverList(NetworkLibraryImpl* library,
+ const std::string& service_path) {
+ network_monitor_ = MonitorNetworkService(&NetworkStatusChangedHandler,
+ service_path.c_str(),
+ library);
+ }
+
+ virtual ~NetworkObserverList() {
+ if (network_monitor_)
+ DisconnectPropertyChangeMonitor(network_monitor_);
+ }
+
+ private:
+ static void NetworkStatusChangedHandler(void* object,
+ const char* path,
+ const char* key,
+ const Value* value) {
+ NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
+ DCHECK(networklib);
+ networklib->UpdateNetworkStatus(path, key, value);
+ }
+ PropertyChangeMonitor network_monitor_;
+ };
+
+ typedef std::map<std::string, NetworkObserverList*> NetworkObserverMap;
+
+ static void NetworkManagerStatusChangedHandler(void* object,
+ const char* path,
+ const char* key,
+ const Value* value) {
+ NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
+ DCHECK(networklib);
+ networklib->NetworkStatusChanged();
}
static void DataPlanUpdateHandler(void* object,
const char* modem_service_path,
const CellularDataPlanList* dataplan) {
- NetworkLibraryImpl* network = static_cast<NetworkLibraryImpl*>(object);
- DCHECK(network);
+ NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
+ if (!networklib || !networklib->cellular_network()) {
+ // This might happen if an update is received as we are shutting down.
+ return;
+ }
// Store data plan for currently connected cellular network.
- if (network->cellular_network().service_path()
+ if (networklib->cellular_network()->service_path()
.compare(modem_service_path) == 0) {
if (dataplan != NULL) {
- network->UpdateCellularDataPlan(*dataplan);
+ networklib->UpdateCellularDataPlan(dataplan);
}
}
}
static void ParseSystem(SystemInfo* system,
- EthernetNetwork* ethernet,
+ EthernetNetwork** ethernet,
WifiNetworkVector* wifi_networks,
CellularNetworkVector* cellular_networks,
- WifiNetworkVector* remembered_wifi_networks,
- CellularNetworkVector* remembered_cellular_networks) {
- DLOG(INFO) << "ParseSystem:";
- ethernet->Clear();
+ WifiNetworkVector* remembered_wifi_networks) {
+ DVLOG(1) << "ParseSystem:";
+ DCHECK(!(*ethernet));
for (int i = 0; i < system->service_size; i++) {
- const ServiceInfo service = *system->GetServiceInfo(i);
- DLOG(INFO) << " (" << service.type <<
- ") " << service.name <<
- " mode=" << service.mode <<
- " state=" << service.state <<
- " sec=" << service.security <<
- " req=" << service.passphrase_required <<
- " pass=" << service.passphrase <<
- " id=" << service.identity <<
- " certpath=" << service.cert_path <<
- " str=" << service.strength <<
- " fav=" << service.favorite <<
- " auto=" << service.auto_connect <<
- " error=" << service.error;
+ const ServiceInfo* service = system->GetServiceInfo(i);
+ DVLOG(1) << " (" << service->type << ") " << service->name
+ << " mode=" << service->mode
+ << " state=" << service->state
+ << " sec=" << service->security
+ << " req=" << service->passphrase_required
+ << " pass=" << service->passphrase
+ << " id=" << service->identity
+ << " certpath=" << service->cert_path
+ << " str=" << service->strength
+ << " fav=" << service->favorite
+ << " auto=" << service->auto_connect
+ << " is_active=" << service->is_active
+ << " error=" << service->error;
// Once a connected ethernet service is found, disregard other ethernet
// services that are also found
- if (service.type == TYPE_ETHERNET && !(ethernet->connected()))
- ethernet->ConfigureFromService(service);
- else if (service.type == TYPE_WIFI)
- wifi_networks->push_back(WifiNetwork(service));
- else if (service.type == TYPE_CELLULAR)
- cellular_networks->push_back(CellularNetwork(service));
+ if (service->type == TYPE_ETHERNET)
+ (*ethernet) = new EthernetNetwork(service);
+ else if (service->type == TYPE_WIFI) {
+ wifi_networks->push_back(new WifiNetwork(service));
+ } else if (service->type == TYPE_CELLULAR) {
+ cellular_networks->push_back(new CellularNetwork(service));
+ }
}
- DLOG(INFO) << "Remembered networks:";
+
+ // Create placeholder network for ethernet even if the service is not
+ // detected at this moment.
+ if (!(*ethernet))
+ (*ethernet) = new EthernetNetwork();
+
+ DVLOG(1) << "Remembered networks:";
for (int i = 0; i < system->remembered_service_size; i++) {
- const ServiceInfo& service = *system->GetRememberedServiceInfo(i);
- // Only serices marked as auto_connect are considered remembered networks.
+ const ServiceInfo* service = system->GetRememberedServiceInfo(i);
+ // Only services marked as auto_connect are considered remembered
+ // networks.
// TODO(chocobo): Don't add to remembered service if currently available.
- if (service.auto_connect) {
- DLOG(INFO) << " (" << service.type <<
- ") " << service.name <<
- " mode=" << service.mode <<
- " sec=" << service.security <<
- " pass=" << service.passphrase <<
- " id=" << service.identity <<
- " certpath=" << service.cert_path <<
- " auto=" << service.auto_connect;
- if (service.type == TYPE_WIFI)
- remembered_wifi_networks->push_back(WifiNetwork(service));
- else if (service.type == TYPE_CELLULAR)
- remembered_cellular_networks->push_back(CellularNetwork(service));
+ if (service->auto_connect) {
+ DVLOG(1) << " (" << service->type << ") " << service->name
+ << " mode=" << service->mode
+ << " sec=" << service->security
+ << " pass=" << service->passphrase
+ << " id=" << service->identity
+ << " certpath=" << service->cert_path
+ << " auto=" << service->auto_connect;
+ if (service->type == TYPE_WIFI) {
+ remembered_wifi_networks->push_back(new WifiNetwork(service));
+ }
}
}
}
void Init() {
- // First, get the currently available networks. This data is cached
+ // First, get the currently available networks. This data is cached
// on the connman side, so the call should be quick.
- LOG(INFO) << "Getting initial CrOS network info.";
+ VLOG(1) << "Getting initial CrOS network info.";
UpdateSystemInfo();
-
- LOG(INFO) << "Registering for network status updates.";
- // Now, register to receive updates on network status.
- network_status_connection_ = MonitorNetwork(&NetworkStatusChangedHandler,
- this);
- LOG(INFO) << "Registering for cellular data plan updates.";
- data_plan_monitor_ = MonitorCellularDataPlan(&DataPlanUpdateHandler, this);
}
void InitTestData() {
- ethernet_.Clear();
- ethernet_.set_connected(true);
- ethernet_.set_service_path("eth1");
+ ethernet_ = new EthernetNetwork();
+ ethernet_->set_connected(true);
+ ethernet_->set_service_path("eth1");
+ STLDeleteElements(&wifi_networks_);
wifi_networks_.clear();
- WifiNetwork wifi1 = WifiNetwork();
- wifi1.set_service_path("fw1");
- wifi1.set_name("Fake Wifi 1");
- wifi1.set_strength(90);
- wifi1.set_connected(false);
- wifi1.set_encryption(SECURITY_NONE);
+ WifiNetwork* wifi1 = new WifiNetwork();
+ wifi1->set_service_path("fw1");
+ wifi1->set_name("Fake Wifi 1");
+ wifi1->set_strength(90);
+ wifi1->set_connected(false);
+ wifi1->set_encryption(SECURITY_NONE);
wifi_networks_.push_back(wifi1);
- WifiNetwork wifi2 = WifiNetwork();
- wifi2.set_service_path("fw2");
- wifi2.set_name("Fake Wifi 2");
- wifi2.set_strength(70);
- wifi2.set_connected(true);
- wifi2.set_encryption(SECURITY_WEP);
+ WifiNetwork* wifi2 = new WifiNetwork();
+ wifi2->set_service_path("fw2");
+ wifi2->set_name("Fake Wifi 2");
+ wifi2->set_strength(70);
+ wifi2->set_connected(true);
+ wifi2->set_encryption(SECURITY_WEP);
wifi_networks_.push_back(wifi2);
- WifiNetwork wifi3 = WifiNetwork();
- wifi3.set_service_path("fw3");
- wifi3.set_name("Fake Wifi 3");
- wifi3.set_strength(50);
- wifi3.set_connected(false);
- wifi3.set_encryption(SECURITY_WEP);
+ WifiNetwork* wifi3 = new WifiNetwork();
+ wifi3->set_service_path("fw3");
+ wifi3->set_name("Fake Wifi 3");
+ wifi3->set_strength(50);
+ wifi3->set_connected(false);
+ wifi3->set_encryption(SECURITY_WEP);
wifi_networks_.push_back(wifi3);
wifi_ = wifi2;
+ STLDeleteElements(&cellular_networks_);
cellular_networks_.clear();
- cellular_networks_.clear();
- CellularNetwork cellular1 = CellularNetwork();
- cellular1.set_service_path("fc1");
- cellular1.set_name("Fake Cellular 1");
- cellular1.set_strength(90);
- cellular1.set_connected(false);
+ CellularNetwork* cellular1 = new CellularNetwork();
+ cellular1->set_service_path("fc1");
+ cellular1->set_name("Fake Cellular 1");
+ cellular1->set_strength(70);
+ cellular1->set_connected(true);
+ cellular1->set_activation_state(ACTIVATION_STATE_PARTIALLY_ACTIVATED);
+ cellular1->set_payment_url(std::string("http://www.google.com"));
cellular_networks_.push_back(cellular1);
-
- CellularNetwork cellular2 = CellularNetwork();
- cellular2.set_service_path("fc2");
- cellular2.set_name("Fake Cellular 2");
- cellular2.set_strength(70);
- cellular2.set_connected(true);
- cellular_networks_.push_back(cellular2);
-
- CellularNetwork cellular3 = CellularNetwork();
- cellular3.set_service_path("fc3");
- cellular3.set_name("Fake Cellular 3");
- cellular3.set_strength(50);
- cellular3.set_connected(false);
- cellular_networks_.push_back(cellular3);
-
- cellular_ = cellular2;
+ cellular_ = cellular1;
remembered_wifi_networks_.clear();
- remembered_wifi_networks_.push_back(wifi2);
-
- remembered_cellular_networks_.clear();
- remembered_cellular_networks_.push_back(cellular2);
+ remembered_wifi_networks_.push_back(new WifiNetwork(*wifi2));
int devices = (1 << TYPE_ETHERNET) | (1 << TYPE_WIFI) |
(1 << TYPE_CELLULAR);
@@ -1030,55 +1331,38 @@ class NetworkLibraryImpl : public NetworkLibrary {
enabled_devices_ = devices;
connected_devices_ = devices;
offline_mode_ = false;
-
- chromeos::CellularDataPlan test_plan;
- test_plan.plan_name = "Fake plan";
- test_plan.data_bytes_used = 5LL * 1024LL * 1024LL * 1024LL;
- test_plan.plan_start_time =
- (base::Time::Now() - base::TimeDelta::FromDays(15)).ToInternalValue() /
- base::Time::kMicrosecondsPerSecond;
- test_plan.plan_end_time =
- (base::Time::Now() + base::TimeDelta::FromDays(12)).ToInternalValue() /
- base::Time::kMicrosecondsPerSecond;
- test_plan.plan_data_bytes = 20LL * 1024LL * 1024LL * 1024LL;
- test_plan.plan_type = CELLULAR_DATA_PLAN_METERED_PAID;
- test_plan.update_time = base::Time::Now().ToInternalValue() /
- base::Time::kMicrosecondsPerSecond;
- chromeos::CellularDataPlanList test_plans;
- test_plans.push_back(test_plan);
- cellular_.SetDataPlans(test_plans);
}
void UpdateSystemInfo() {
if (EnsureCrosLoaded()) {
- UpdateNetworkStatus();
+ UpdateNetworkManagerStatus();
}
}
WifiNetwork* GetWifiNetworkByName(const std::string& name) {
for (size_t i = 0; i < wifi_networks_.size(); ++i) {
- if (wifi_networks_[i].name().compare(name) == 0) {
- return &wifi_networks_[i];
+ if (wifi_networks_[i]->name().compare(name) == 0) {
+ return wifi_networks_[i];
}
}
return NULL;
}
- template<typename T> T* GetWirelessNetworkByPath(
+ template<typename T> T GetWirelessNetworkByPath(
std::vector<T>& networks, const std::string& path) {
typedef typename std::vector<T>::iterator iter_t;
iter_t iter = std::find_if(networks.begin(), networks.end(),
WirelessNetwork::ServicePathEq(path));
- return (iter != networks.end()) ? &(*iter) : NULL;
+ return (iter != networks.end()) ? *iter : NULL;
}
// const version
- template<typename T> const T* GetWirelessNetworkByPath(
+ template<typename T> const T GetWirelessNetworkByPath(
const std::vector<T>& networks, const std::string& path) const {
typedef typename std::vector<T>::const_iterator iter_t;
iter_t iter = std::find_if(networks.begin(), networks.end(),
WirelessNetwork::ServicePathEq(path));
- return (iter != networks.end()) ? &(*iter) : NULL;
+ return (iter != networks.end()) ? *iter : NULL;
}
void EnableNetworkDeviceType(ConnectionType device, bool enable) {
@@ -1100,53 +1384,68 @@ class NetworkLibraryImpl : public NetworkLibrary {
EnableNetworkDevice(device, enable);
}
- void NotifyNetworkChanged() {
- FOR_EACH_OBSERVER(Observer, observers_, NetworkChanged(this));
+ void NotifyNetworkManagerChanged() {
+ FOR_EACH_OBSERVER(NetworkManagerObserver,
+ network_manager_observers_,
+ OnNetworkManagerChanged(this));
+ }
+
+ void NotifyNetworkChanged(Network* network) {
+ DCHECK(network);
+ NetworkObserverMap::const_iterator iter = network_observers_.find(
+ network->service_path());
+ if (iter != network_observers_.end()) {
+ FOR_EACH_OBSERVER(NetworkObserver,
+ *(iter->second),
+ OnNetworkChanged(this, network));
+ } else {
+ NOTREACHED() <<
+ "There weren't supposed to be any property change observers of " <<
+ network->service_path();
+ }
}
void NotifyCellularDataPlanChanged() {
- FOR_EACH_OBSERVER(Observer, observers_, CellularDataPlanChanged(this));
+ FOR_EACH_OBSERVER(CellularDataPlanObserver,
+ data_plan_observers_,
+ OnCellularDataPlanChanged(this));
}
- void UpdateNetworkStatus() {
+ void UpdateNetworkManagerStatus() {
// Make sure we run on UI thread.
- if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- NewRunnableMethod(this,
- &NetworkLibraryImpl::UpdateNetworkStatus));
- return;
- }
+ CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+ update_task_ = NULL;
+ VLOG(1) << "Updating Network Status";
SystemInfo* system = GetSystemInfo();
if (!system)
return;
- wifi_networks_.clear();
- cellular_networks_.clear();
- remembered_wifi_networks_.clear();
- remembered_cellular_networks_.clear();
+ std::string prev_cellular_service_path = cellular_ ?
+ cellular_->service_path() : std::string();
+
+ ClearNetworks();
+
ParseSystem(system, &ethernet_, &wifi_networks_, &cellular_networks_,
- &remembered_wifi_networks_, &remembered_cellular_networks_);
+ &remembered_wifi_networks_);
- wifi_ = WifiNetwork();
+ wifi_ = NULL;
for (size_t i = 0; i < wifi_networks_.size(); i++) {
- if (wifi_networks_[i].connecting_or_connected()) {
+ if (wifi_networks_[i]->connecting_or_connected()) {
wifi_ = wifi_networks_[i];
break; // There is only one connected or connecting wifi network.
}
}
- std::string prev_service_path = cellular_.service_path();
- cellular_ = CellularNetwork();
+ cellular_ = NULL;
for (size_t i = 0; i < cellular_networks_.size(); i++) {
- if (cellular_networks_[i].connecting_or_connected()) {
- // If new cellular, then update data plan list.
- if (cellular_networks_[i].service_path() != prev_service_path) {
- CellularDataPlanList list;
- RetrieveCellularDataPlans(cellular_.service_path().c_str(), &list);
- UpdateCellularDataPlan(list);
- }
+ if (cellular_networks_[i]->connecting_or_connected()) {
cellular_ = cellular_networks_[i];
+ // If new cellular, then request update of the data plan list.
+ if (cellular_networks_[i]->service_path() !=
+ prev_cellular_service_path) {
+ RefreshCellularDataPlans(cellular_);
+ }
break; // There is only one connected or connecting cellular network.
}
}
@@ -1156,31 +1455,122 @@ class NetworkLibraryImpl : public NetworkLibrary {
connected_devices_ = system->connected_technologies;
offline_mode_ = system->offline_mode;
- NotifyNetworkChanged();
+ NotifyNetworkManagerChanged();
FreeSystemInfo(system);
}
- void UpdateCellularDataPlan(const CellularDataPlanList& data_plans) {
- cellular_.SetDataPlans(data_plans);
+ void UpdateNetworkStatus(const char* path,
+ const char* key,
+ const Value* value) {
+ if (key == NULL || value == NULL)
+ return;
+ // Make sure we run on UI thread.
+ if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+ BrowserThread::PostTask(
+ BrowserThread::UI, FROM_HERE,
+ NewRunnableMethod(this,
+ &NetworkLibraryImpl::UpdateNetworkStatus,
+ path, key, value));
+ return;
+ }
+
+ bool boolval = false;
+ int intval = 0;
+ std::string stringval;
+ Network* network;
+ if (ethernet_->service_path() == path) {
+ network = ethernet_;
+ } else {
+ CellularNetwork* cellular =
+ GetWirelessNetworkByPath(cellular_networks_, path);
+ WifiNetwork* wifi =
+ GetWirelessNetworkByPath(wifi_networks_, path);
+ if (cellular == NULL && wifi == NULL)
+ return;
+
+ WirelessNetwork* wireless;
+ if (wifi != NULL)
+ wireless = static_cast<WirelessNetwork*>(wifi);
+ else
+ wireless = static_cast<WirelessNetwork*>(cellular);
+
+ if (strcmp(key, kSignalStrengthProperty) == 0) {
+ if (value->GetAsInteger(&intval))
+ wireless->set_strength(intval);
+ } else if (cellular != NULL) {
+ if (strcmp(key, kRestrictedPoolProperty) == 0) {
+ if (value->GetAsBoolean(&boolval))
+ cellular->set_restricted_pool(boolval);
+ } else if (strcmp(key, kActivationStateProperty) == 0) {
+ if (value->GetAsString(&stringval))
+ cellular->set_activation_state(ParseActivationState(stringval));
+ } else if (strcmp(key, kPaymentURLProperty) == 0) {
+ if (value->GetAsString(&stringval))
+ cellular->set_payment_url(stringval);
+ } else if (strcmp(key, kNetworkTechnologyProperty) == 0) {
+ if (value->GetAsString(&stringval))
+ cellular->set_network_technology(
+ ParseNetworkTechnology(stringval));
+ } else if (strcmp(key, kRoamingStateProperty) == 0) {
+ if (value->GetAsString(&stringval))
+ cellular->set_roaming_state(ParseRoamingState(stringval));
+ }
+ }
+ network = wireless;
+ }
+ if (strcmp(key, kIsActiveProperty) == 0) {
+ if (value->GetAsBoolean(&boolval))
+ network->set_active(boolval);
+ } else if (strcmp(key, kStateProperty) == 0) {
+ if (value->GetAsString(&stringval))
+ network->set_state(ParseState(stringval));
+ }
+ NotifyNetworkChanged(network);
+ }
+
+ void UpdateCellularDataPlan(const CellularDataPlanList* data_plans) {
+ DCHECK(cellular_);
+ cellular_->SetDataPlans(data_plans);
NotifyCellularDataPlanChanged();
}
- ObserverList<Observer> observers_;
+ void ClearNetworks() {
+ if (ethernet_)
+ delete ethernet_;
+ ethernet_ = NULL;
+ wifi_ = NULL;
+ cellular_ = NULL;
+ STLDeleteElements(&wifi_networks_);
+ wifi_networks_.clear();
+ STLDeleteElements(&cellular_networks_);
+ cellular_networks_.clear();
+ STLDeleteElements(&remembered_wifi_networks_);
+ remembered_wifi_networks_.clear();
+ }
+
+ // Network manager observer list
+ ObserverList<NetworkManagerObserver> network_manager_observers_;
+
+ // Cellular data plan observer list
+ ObserverList<CellularDataPlanObserver> data_plan_observers_;
- // The network status connection for monitoring network status changes.
- MonitorNetworkConnection network_status_connection_;
+ // Network observer map
+ NetworkObserverMap network_observers_;
+
+ // For monitoring network manager status changes.
+ PropertyChangeMonitor network_manager_monitor_;
// For monitoring data plan changes to the connected cellular network.
DataPlanUpdateMonitor data_plan_monitor_;
// The ethernet network.
- EthernetNetwork ethernet_;
+ EthernetNetwork* ethernet_;
// The list of available wifi networks.
WifiNetworkVector wifi_networks_;
// The current connected (or connecting) wifi network.
- WifiNetwork wifi_;
+ WifiNetwork* wifi_;
// The remembered wifi networks.
WifiNetworkVector remembered_wifi_networks_;
@@ -1189,10 +1579,7 @@ class NetworkLibraryImpl : public NetworkLibrary {
CellularNetworkVector cellular_networks_;
// The current connected (or connecting) cellular network.
- CellularNetwork cellular_;
-
- // The remembered cellular networks.
- CellularNetworkVector remembered_cellular_networks_;
+ CellularNetwork* cellular_;
// The current available network devices. Bitwise flag of ConnectionTypes.
int available_devices_;
@@ -1205,26 +1592,43 @@ class NetworkLibraryImpl : public NetworkLibrary {
bool offline_mode_;
+ // Delayed task to retrieve the network information.
+ CancelableTask* update_task_;
+
DISALLOW_COPY_AND_ASSIGN(NetworkLibraryImpl);
};
class NetworkLibraryStubImpl : public NetworkLibrary {
public:
- NetworkLibraryStubImpl() : ip_address_("1.1.1.1") {}
- ~NetworkLibraryStubImpl() {}
- void AddObserver(Observer* observer) {}
- void RemoveObserver(Observer* observer) {}
- virtual const EthernetNetwork& ethernet_network() const {
+ NetworkLibraryStubImpl()
+ : ip_address_("1.1.1.1"),
+ ethernet_(new EthernetNetwork()),
+ wifi_(NULL),
+ cellular_(NULL) {
+ }
+ ~NetworkLibraryStubImpl() { if (ethernet_) delete ethernet_; }
+ virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {}
+ virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {}
+ virtual void AddNetworkObserver(const std::string& service_path,
+ NetworkObserver* observer) {}
+ virtual void RemoveNetworkObserver(const std::string& service_path,
+ NetworkObserver* observer) {}
+ virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {}
+ virtual void AddCellularDataPlanObserver(
+ CellularDataPlanObserver* observer) {}
+ virtual void RemoveCellularDataPlanObserver(
+ CellularDataPlanObserver* observer) {}
+ virtual EthernetNetwork* ethernet_network() {
return ethernet_;
}
virtual bool ethernet_connecting() const { return false; }
virtual bool ethernet_connected() const { return true; }
- virtual const WifiNetwork& wifi_network() const {
+ virtual WifiNetwork* wifi_network() {
return wifi_;
}
virtual bool wifi_connecting() const { return false; }
virtual bool wifi_connected() const { return false; }
- virtual const CellularNetwork& cellular_network() const {
+ virtual CellularNetwork* cellular_network() {
return cellular_;
}
virtual bool cellular_connecting() const { return false; }
@@ -1242,42 +1646,49 @@ class NetworkLibraryStubImpl : public NetworkLibrary {
virtual const CellularNetworkVector& cellular_networks() const {
return cellular_networks_;
}
- virtual const CellularNetworkVector& remembered_cellular_networks() const {
- return cellular_networks_;
+ virtual bool has_cellular_networks() const {
+ return cellular_networks_.begin() != cellular_networks_.end();
}
-
/////////////////////////////////////////////////////////////////////////////
- virtual bool FindWifiNetworkByPath(
- const std::string& path, WifiNetwork* result) const { return false; }
- virtual bool FindCellularNetworkByPath(
- const std::string& path, CellularNetwork* result) const { return false; }
+ virtual WifiNetwork* FindWifiNetworkByPath(
+ const std::string& path) { return NULL; }
+ virtual CellularNetwork* FindCellularNetworkByPath(
+ const std::string& path) { return NULL; }
virtual void RequestWifiScan() {}
virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) {
return false;
}
- virtual void ConnectToWifiNetwork(WifiNetwork network,
+ virtual bool ConnectToWifiNetwork(const WifiNetwork* network,
const std::string& password,
const std::string& identity,
- const std::string& certpath) {}
- virtual void ConnectToWifiNetwork(const std::string& ssid,
+ const std::string& certpath) {
+ return true;
+ }
+ virtual bool ConnectToWifiNetwork(ConnectionSecurity security,
+ const std::string& ssid,
const std::string& password,
const std::string& identity,
const std::string& certpath,
- bool auto_connect) {}
- virtual void ConnectToCellularNetwork(CellularNetwork network) {}
- virtual void RefreshCellularDataPlans(const CellularNetwork& network) {}
- virtual void DisconnectFromWirelessNetwork(const WirelessNetwork& network) {}
- virtual void SaveCellularNetwork(const CellularNetwork& network) {}
- virtual void SaveWifiNetwork(const WifiNetwork& network) {}
- virtual void ForgetWirelessNetwork(const std::string& service_path) {}
+ bool auto_connect) {
+ return true;
+ }
+ virtual bool ConnectToCellularNetwork(const CellularNetwork* network) {
+ return true;
+ }
+ virtual void RefreshCellularDataPlans(const CellularNetwork* network) {}
+ virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {}
+ virtual void SaveCellularNetwork(const CellularNetwork* network) {}
+ virtual void SaveWifiNetwork(const WifiNetwork* network) {}
+ virtual void ForgetWifiNetwork(const std::string& service_path) {}
virtual bool ethernet_available() const { return true; }
virtual bool wifi_available() const { return false; }
virtual bool cellular_available() const { return false; }
virtual bool ethernet_enabled() const { return true; }
virtual bool wifi_enabled() const { return false; }
virtual bool cellular_enabled() const { return false; }
+ virtual const Network* active_network() const { return NULL; }
virtual bool offline_mode() const { return false; }
virtual void EnableEthernetNetworkDevice(bool enable) {}
virtual void EnableWifiNetworkDevice(bool enable) {}
@@ -1289,13 +1700,12 @@ class NetworkLibraryStubImpl : public NetworkLibrary {
return NetworkIPConfigVector();
}
virtual std::string GetHtmlInfo(int refresh) { return std::string(); }
- virtual void UpdateSystemInfo() {}
private:
std::string ip_address_;
- EthernetNetwork ethernet_;
- WifiNetwork wifi_;
- CellularNetwork cellular_;
+ EthernetNetwork* ethernet_;
+ WifiNetwork* wifi_;
+ CellularNetwork* cellular_;
WifiNetworkVector wifi_networks_;
CellularNetworkVector cellular_networks_;
};
diff --git a/chrome/browser/chromeos/cros/network_library.h b/chrome/browser/chromeos/cros/network_library.h
index 5426da1..8296660 100644
--- a/chrome/browser/chromeos/cros/network_library.h
+++ b/chrome/browser/chromeos/cros/network_library.h
@@ -15,6 +15,8 @@
#include "base/timer.h"
#include "cros/chromeos_network.h"
+class Value;
+
namespace chromeos {
// Cellular network is considered low data when less than 60 minues.
@@ -38,25 +40,22 @@ class Network {
ConnectionState connection_state() const { return state_; }
bool connecting() const { return state_ == STATE_ASSOCIATION ||
state_ == STATE_CONFIGURATION || state_ == STATE_CARRIER; }
+ bool configuring() const { return state_ == STATE_CONFIGURATION; }
bool connected() const { return state_ == STATE_READY; }
bool connecting_or_connected() const { return connecting() || connected(); }
bool failed() const { return state_ == STATE_FAILURE; }
+ bool failed_or_disconnected() const { return failed() ||
+ state_ == STATE_IDLE; }
ConnectionError error() const { return error_; }
ConnectionState state() const { return state_; }
-
- void set_service_path(const std::string& service_path) {
- service_path_ = service_path; }
- void set_connecting(bool connecting) { state_ = (connecting ?
- STATE_ASSOCIATION : STATE_IDLE); }
- void set_connected(bool connected) { state_ = (connected ?
- STATE_READY : STATE_IDLE); }
+ // Is this the active network, i.e, the one through which
+ // network traffic is being routed? A network can be connected,
+ // but not be carrying traffic.
+ bool is_active() const { return is_active_; }
// Clear the fields.
virtual void Clear();
- // Configure the Network from a ServiceInfo object.
- virtual void ConfigureFromService(const ServiceInfo& service);
-
// Return a string representation of the state code.
std::string GetStateString() const;
@@ -67,7 +66,10 @@ class Network {
Network()
: type_(TYPE_UNKNOWN),
state_(STATE_UNKNOWN),
- error_(ERROR_UNKNOWN) {}
+ error_(ERROR_UNKNOWN),
+ is_active_(false) {}
+ explicit Network(const Network& network);
+ explicit Network(const ServiceInfo* service);
virtual ~Network() {}
std::string service_path_;
@@ -76,6 +78,19 @@ class Network {
ConnectionType type_;
ConnectionState state_;
ConnectionError error_;
+ bool is_active_;
+
+ private:
+ void set_service_path(const std::string& service_path) {
+ service_path_ = service_path; }
+ void set_connecting(bool connecting) { state_ = (connecting ?
+ STATE_ASSOCIATION : STATE_IDLE); }
+ void set_connected(bool connected) { state_ = (connected ?
+ STATE_READY : STATE_IDLE); }
+ void set_state(ConnectionState state) { state_ = state; }
+ void set_active(bool is_active) { is_active_ = is_active; }
+
+ friend class NetworkLibraryImpl;
};
class EthernetNetwork : public Network {
@@ -83,6 +98,15 @@ class EthernetNetwork : public Network {
EthernetNetwork() : Network() {
type_ = TYPE_ETHERNET;
}
+
+ explicit EthernetNetwork(const EthernetNetwork& network)
+ : Network(network) {
+ type_ = TYPE_ETHERNET;
+ }
+
+ explicit EthernetNetwork(const ServiceInfo* service) : Network(service) {
+ type_ = TYPE_ETHERNET;
+ }
};
class WirelessNetwork : public Network {
@@ -95,8 +119,8 @@ class WirelessNetwork : public Network {
// We frequently want to compare networks by service path.
struct ServicePathEq {
explicit ServicePathEq(const std::string& path_in) : path(path_in) {}
- bool operator()(const WirelessNetwork& a) {
- return a.service_path().compare(path) == 0;
+ bool operator()(const WirelessNetwork* a) {
+ return a->service_path().compare(path) == 0;
}
const std::string& path;
};
@@ -106,14 +130,11 @@ class WirelessNetwork : public Network {
bool auto_connect() const { return auto_connect_; }
bool favorite() const { return favorite_; }
- void set_name(const std::string& name) { name_ = name; }
- void set_strength(int strength) { strength_ = strength; }
void set_auto_connect(bool auto_connect) { auto_connect_ = auto_connect; }
void set_favorite(bool favorite) { favorite_ = favorite; }
// Network overrides.
virtual void Clear();
- virtual void ConfigureFromService(const ServiceInfo& service);
protected:
WirelessNetwork()
@@ -121,13 +142,48 @@ class WirelessNetwork : public Network {
strength_(0),
auto_connect_(false),
favorite_(false) {}
-
+ explicit WirelessNetwork(const WirelessNetwork& network);
+ explicit WirelessNetwork(const ServiceInfo* service);
+ virtual ~WirelessNetwork() {}
std::string name_;
int strength_;
bool auto_connect_;
bool favorite_;
+
+ private:
+ void set_name(const std::string& name) { name_ = name; }
+ void set_strength(int strength) { strength_ = strength; }
+
+ friend class NetworkLibraryImpl;
+};
+
+class CellularDataPlan {
+ public:
+ CellularDataPlan() :
+ plan_name("Unknown"),
+ plan_type(CELLULAR_DATA_PLAN_UNLIMITED),
+ plan_data_bytes(0),
+ data_bytes_used(0) { }
+ explicit CellularDataPlan(const CellularDataPlanInfo &plan) :
+ plan_name(plan.plan_name?plan.plan_name:""),
+ plan_type(plan.plan_type),
+ update_time(base::Time::FromInternalValue(plan.update_time)),
+ plan_start_time(base::Time::FromInternalValue(plan.plan_start_time)),
+ plan_end_time(base::Time::FromInternalValue(plan.plan_end_time)),
+ plan_data_bytes(plan.plan_data_bytes),
+ data_bytes_used(plan.data_bytes_used) { }
+
+ std::string plan_name;
+ CellularDataPlanType plan_type;
+ base::Time update_time;
+ base::Time plan_start_time;
+ base::Time plan_end_time;
+ int64 plan_data_bytes;
+ int64 data_bytes_used;
};
+typedef std::vector<CellularDataPlan> CellularDataPlanVector;
+
class CellularNetwork : public WirelessNetwork {
public:
enum DataLeft {
@@ -138,11 +194,9 @@ class CellularNetwork : public WirelessNetwork {
};
CellularNetwork();
- explicit CellularNetwork(const ServiceInfo& service)
- : WirelessNetwork() {
- ConfigureFromService(service);
- }
-
+ explicit CellularNetwork(const CellularNetwork& network);
+ explicit CellularNetwork(const ServiceInfo* service);
+ virtual ~CellularNetwork();
// Starts device activation process. Returns false if the device state does
// not permit activation.
bool StartActivation() const;
@@ -173,14 +227,17 @@ class CellularNetwork : public WirelessNetwork {
// WirelessNetwork overrides.
virtual void Clear();
- virtual void ConfigureFromService(const ServiceInfo& service);
- const CellularDataPlanList& GetDataPlans() const {
+ const CellularDataPlanVector& GetDataPlans() const {
return data_plans_;
}
- void SetDataPlans(const CellularDataPlanList& data_plans) {
- data_plans_ = data_plans;
+ void SetDataPlans(const CellularDataPlanList* data_plan_list) {
+ data_plans_.clear();
+ for (size_t i = 0; i < data_plan_list->plans_size; i++) {
+ const CellularDataPlanInfo* info(data_plan_list->GetCellularDataPlan(i));
+ data_plans_.push_back(CellularDataPlan(*info));
+ }
}
// Return a string representation of network technology.
std::string GetNetworkTechnologyString() const;
@@ -189,7 +246,11 @@ class CellularNetwork : public WirelessNetwork {
// Return a string representation of roaming state.
std::string GetRoamingStateString() const;
+ // Return a string representation of |activation_state|.
+ static std::string ActivationStateToString(ActivationState activation_state);
+
protected:
+
ActivationState activation_state_;
NetworkTechnology network_technology_;
NetworkRoamingState roaming_state_;
@@ -212,17 +273,38 @@ class CellularNetwork : public WirelessNetwork {
std::string hardware_revision_;
std::string last_update_;
unsigned int prl_version_;
- CellularDataPlanList data_plans_;
+ CellularDataPlanVector data_plans_;
+
+ private:
+ void set_activation_state(ActivationState state) {
+ activation_state_ = state;
+ }
+ void set_payment_url(const std::string& url) {
+ payment_url_ = url;
+ }
+ void set_network_technology(NetworkTechnology technology) {
+ network_technology_ = technology;
+ }
+ void set_roaming_state(NetworkRoamingState state) {
+ roaming_state_ = state;
+ }
+ void set_restricted_pool(bool restricted_pool) {
+ restricted_pool_ = restricted_pool;
+ }
+
+ friend class NetworkLibraryImpl;
};
class WifiNetwork : public WirelessNetwork {
public:
WifiNetwork();
- explicit WifiNetwork(const ServiceInfo& service);
+ explicit WifiNetwork(const WifiNetwork& network);
+ explicit WifiNetwork(const ServiceInfo* service);
bool encrypted() const { return encryption_ != SECURITY_NONE; }
ConnectionSecurity encryption() const { return encryption_; }
const std::string& passphrase() const { return passphrase_; }
+ bool passphrase_required() const { return passphrase_required_; }
const std::string& identity() const { return identity_; }
const std::string& cert_path() const { return cert_path_; }
@@ -241,7 +323,6 @@ class WifiNetwork : public WirelessNetwork {
// WirelessNetwork overrides.
virtual void Clear();
- virtual void ConfigureFromService(const ServiceInfo& service);
// Return a string representation of the encryption code.
// This not translated and should be only used for debugging purposes.
@@ -253,12 +334,13 @@ class WifiNetwork : public WirelessNetwork {
protected:
ConnectionSecurity encryption_;
std::string passphrase_;
+ bool passphrase_required_;
std::string identity_;
std::string cert_path_;
};
-typedef std::vector<WifiNetwork> WifiNetworkVector;
-typedef std::vector<CellularNetwork> CellularNetworkVector;
+typedef std::vector<chromeos::WifiNetwork*> WifiNetworkVector;
+typedef std::vector<chromeos::CellularNetwork*> CellularNetworkVector;
struct CellTower {
enum RadioType {
@@ -318,30 +400,60 @@ typedef std::vector<NetworkIPConfig> NetworkIPConfigVector;
// library like this: chromeos::CrosLibrary::Get()->GetNetworkLibrary()
class NetworkLibrary {
public:
- class Observer {
+ class NetworkManagerObserver {
+ public:
+ // Called when the state of the network manager has changed,
+ // for example, networks have appeared or disappeared.
+ virtual void OnNetworkManagerChanged(NetworkLibrary* obj) = 0;
+ };
+
+ class NetworkObserver {
+ public:
+ // Called when the state of a single network has changed,
+ // for example signal strength or connection state.
+ virtual void OnNetworkChanged(NetworkLibrary* cros,
+ const Network* network) = 0;
+ };
+
+ class CellularDataPlanObserver {
public:
- // Called when the network has changed. (wifi networks, and ethernet)
- virtual void NetworkChanged(NetworkLibrary* obj) = 0;
// Called when the cellular data plan has changed.
- virtual void CellularDataPlanChanged(NetworkLibrary* obj) {}
+ virtual void OnCellularDataPlanChanged(NetworkLibrary* obj) = 0;
};
virtual ~NetworkLibrary() {}
- virtual void AddObserver(Observer* observer) = 0;
- virtual void RemoveObserver(Observer* observer) = 0;
+
+ virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) = 0;
+ virtual void RemoveNetworkManagerObserver(
+ NetworkManagerObserver* observer) = 0;
+
+ // An attempt to add an observer that has already been added for a
+ // give service path will be ignored.
+ virtual void AddNetworkObserver(const std::string& service_path,
+ NetworkObserver* observer) = 0;
+ // Remove an observer of a single network
+ virtual void RemoveNetworkObserver(const std::string& service_path,
+ NetworkObserver* observer) = 0;
+ // Stop |observer| from observing any networks
+ virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) = 0;
+
+ virtual void AddCellularDataPlanObserver(
+ CellularDataPlanObserver* observer) = 0;
+ virtual void RemoveCellularDataPlanObserver(
+ CellularDataPlanObserver* observer) = 0;
// Return the active Ethernet network (or a default structure if inactive).
- virtual const EthernetNetwork& ethernet_network() const = 0;
+ virtual EthernetNetwork* ethernet_network() = 0;
virtual bool ethernet_connecting() const = 0;
virtual bool ethernet_connected() const = 0;
// Return the active Wifi network (or a default structure if none active).
- virtual const WifiNetwork& wifi_network() const = 0;
+ virtual WifiNetwork* wifi_network() = 0;
virtual bool wifi_connecting() const = 0;
virtual bool wifi_connected() const = 0;
// Return the active Cellular network (or a default structure if none active).
- virtual const CellularNetwork& cellular_network() const = 0;
+ virtual CellularNetwork* cellular_network() = 0;
virtual bool cellular_connecting() const = 0;
virtual bool cellular_connected() const = 0;
@@ -363,15 +475,12 @@ class NetworkLibrary {
// Returns the current list of cellular networks.
virtual const CellularNetworkVector& cellular_networks() const = 0;
- // Returns the list of remembered cellular networks.
- virtual const CellularNetworkVector& remembered_cellular_networks() const = 0;
-
// Search the current list of networks by path and if the network
// is available, copy the result and return true.
- virtual bool FindWifiNetworkByPath(const std::string& path,
- WifiNetwork* result) const = 0;
- virtual bool FindCellularNetworkByPath(const std::string& path,
- CellularNetwork* result) const = 0;
+ virtual WifiNetwork* FindWifiNetworkByPath(const std::string& path) = 0;
+ virtual CellularNetwork* FindCellularNetworkByPath(
+ const std::string& path) = 0;
+
// Request a scan for new wifi networks.
virtual void RequestWifiScan() = 0;
@@ -386,39 +495,40 @@ class NetworkLibrary {
// TODO(joth): Add GetCellTowers to retrieve a CellTowerVector.
- // Force an update of the system info.
- virtual void UpdateSystemInfo() = 0;
-
// Connect to the specified wireless network with password.
- virtual void ConnectToWifiNetwork(WifiNetwork network,
+ // Returns false if the attempt fails immediately (e.g. passphrase too short).
+ virtual bool ConnectToWifiNetwork(const WifiNetwork* network,
const std::string& password,
const std::string& identity,
const std::string& certpath) = 0;
- // Connect to the specified wifi ssid with password.
- virtual void ConnectToWifiNetwork(const std::string& ssid,
+ // Connect to the specified network with security, ssid, and password.
+ // Returns false if the attempt fails immediately (e.g. passphrase too short).
+ virtual bool ConnectToWifiNetwork(ConnectionSecurity security,
+ const std::string& ssid,
const std::string& password,
const std::string& identity,
const std::string& certpath,
bool auto_connect) = 0;
// Connect to the specified cellular network.
- virtual void ConnectToCellularNetwork(CellularNetwork network) = 0;
+ // Returns false if the attempt fails immediately.
+ virtual bool ConnectToCellularNetwork(const CellularNetwork* network) = 0;
// Initiates cellular data plan refresh. Plan data will be passed through
// Network::Observer::CellularDataPlanChanged callback.
- virtual void RefreshCellularDataPlans(const CellularNetwork& network) = 0;
+ virtual void RefreshCellularDataPlans(const CellularNetwork* network) = 0;
// Disconnect from the specified wireless (either cellular or wifi) network.
virtual void DisconnectFromWirelessNetwork(
- const WirelessNetwork& network) = 0;
+ const WirelessNetwork* network) = 0;
// Save network information including passwords (wifi) and auto-connect.
- virtual void SaveCellularNetwork(const CellularNetwork& network) = 0;
- virtual void SaveWifiNetwork(const WifiNetwork& network) = 0;
+ virtual void SaveCellularNetwork(const CellularNetwork* network) = 0;
+ virtual void SaveWifiNetwork(const WifiNetwork* network) = 0;
- // Forget the passed in wireless (either cellular or wifi) network.
- virtual void ForgetWirelessNetwork(const std::string& service_path) = 0;
+ // Forget the wifi network corresponding to service_path.
+ virtual void ForgetWifiNetwork(const std::string& service_path) = 0;
virtual bool ethernet_available() const = 0;
virtual bool wifi_available() const = 0;
@@ -428,6 +538,8 @@ class NetworkLibrary {
virtual bool wifi_enabled() const = 0;
virtual bool cellular_enabled() const = 0;
+ virtual const Network* active_network() const = 0;
+
virtual bool offline_mode() const = 0;
// Enables/disables the ethernet network device.
diff --git a/chrome/browser/chromeos/cros/power_library.cc b/chrome/browser/chromeos/cros/power_library.cc
index 7caea61..bb5efcd 100644
--- a/chrome/browser/chromeos/cros/power_library.cc
+++ b/chrome/browser/chromeos/cros/power_library.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
@@ -109,12 +109,11 @@ class PowerLibraryImpl : public PowerLibrary {
return;
}
- DLOG(INFO) << "Power" <<
- " lpo=" << status.line_power_on <<
- " sta=" << status.battery_state <<
- " per=" << status.battery_percentage <<
- " tte=" << status.battery_time_to_empty <<
- " ttf=" << status.battery_time_to_full;
+ DVLOG(1) << "Power lpo=" << status.line_power_on
+ << " sta=" << status.battery_state
+ << " per=" << status.battery_percentage
+ << " tte=" << status.battery_time_to_empty
+ << " ttf=" << status.battery_time_to_full;
status_ = status;
FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(this));
}
diff --git a/chrome/browser/chromeos/cros/screen_lock_library.cc b/chrome/browser/chromeos/cros/screen_lock_library.cc
index 3502c26..cd01302 100644
--- a/chrome/browser/chromeos/cros/screen_lock_library.cc
+++ b/chrome/browser/chromeos/cros/screen_lock_library.cc
@@ -35,54 +35,18 @@ class ScreenLockLibraryImpl : public ScreenLockLibrary {
}
void NotifyScreenLockRequested() {
- // Make sure we run on IO thread.
- if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
- BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- NewRunnableMethod(
- this,
- &ScreenLockLibraryImpl::NotifyScreenLockRequested));
- return;
- }
chromeos::NotifyScreenLockRequested();
}
void NotifyScreenLockCompleted() {
- // Make sure we run on IO thread.
- if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
- BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- NewRunnableMethod(
- this,
- &ScreenLockLibraryImpl::NotifyScreenLockCompleted));
- return;
- }
chromeos::NotifyScreenLockCompleted();
}
void NotifyScreenUnlockRequested() {
- // Make sure we run on IO thread.
- if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
- BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- NewRunnableMethod(
- this,
- &ScreenLockLibraryImpl::NotifyScreenUnlockRequested));
- return;
- }
chromeos::NotifyScreenUnlockRequested();
}
void NotifyScreenUnlockCompleted() {
- // Make sure we run on IO thread.
- if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
- BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- NewRunnableMethod(
- this,
- &ScreenLockLibraryImpl::NotifyScreenUnlockCompleted));
- return;
- }
chromeos::NotifyScreenUnlockCompleted();
}
@@ -175,4 +139,3 @@ ScreenLockLibrary* ScreenLockLibrary::GetImpl(bool stub) {
// Allows InvokeLater without adding refcounting. This class is a Singleton and
// won't be deleted until it's last InvokeLater is run.
DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::ScreenLockLibraryImpl);
-
diff --git a/chrome/browser/chromeos/cros/syslogs_library.cc b/chrome/browser/chromeos/cros/syslogs_library.cc
index 8d771b6..fbfa515 100644
--- a/chrome/browser/chromeos/cros/syslogs_library.cc
+++ b/chrome/browser/chromeos/cros/syslogs_library.cc
@@ -13,13 +13,17 @@
namespace chromeos {
+const char kContextFeedback[] = "feedback";
+const char kContextSysInfo[] = "sysinfo";
+
+
class SyslogsLibraryImpl : public SyslogsLibrary {
public:
SyslogsLibraryImpl() {}
virtual ~SyslogsLibraryImpl() {}
virtual Handle RequestSyslogs(
- bool compress_logs,
+ bool compress_logs, bool add_feedback_context,
CancelableRequestConsumerBase* consumer,
ReadCompleteCallback* callback);
@@ -27,7 +31,7 @@ class SyslogsLibraryImpl : public SyslogsLibrary {
// Called from FILE thread.
void ReadSyslogs(
scoped_refptr<CancelableRequest<ReadCompleteCallback> > request,
- bool compress_logs);
+ bool compress_logs, bool add_feedback_context);
void LoadCompressedLogs(const FilePath& zip_file,
std::string* zip_content);
@@ -40,7 +44,7 @@ class SyslogsLibraryStubImpl : public SyslogsLibrary {
SyslogsLibraryStubImpl() {}
virtual ~SyslogsLibraryStubImpl() {}
- virtual Handle RequestSyslogs(bool compress_logs,
+ virtual Handle RequestSyslogs(bool compress_logs, bool add_feedback_context,
CancelableRequestConsumerBase* consumer,
ReadCompleteCallback* callback) {
if (callback)
@@ -60,7 +64,7 @@ SyslogsLibrary* SyslogsLibrary::GetImpl(bool stub) {
CancelableRequestProvider::Handle SyslogsLibraryImpl::RequestSyslogs(
- bool compress_logs,
+ bool compress_logs, bool add_feedback_context,
CancelableRequestConsumerBase* consumer,
ReadCompleteCallback* callback) {
// Register the callback request.
@@ -73,7 +77,8 @@ CancelableRequestProvider::Handle SyslogsLibraryImpl::RequestSyslogs(
BrowserThread::PostTask(
BrowserThread::FILE, FROM_HERE,
NewRunnableMethod(
- this, &SyslogsLibraryImpl::ReadSyslogs, request, compress_logs));
+ this, &SyslogsLibraryImpl::ReadSyslogs, request,
+ compress_logs, add_feedback_context));
return request->handle();
}
@@ -81,7 +86,7 @@ CancelableRequestProvider::Handle SyslogsLibraryImpl::RequestSyslogs(
// Called from FILE thread.
void SyslogsLibraryImpl::ReadSyslogs(
scoped_refptr<CancelableRequest<ReadCompleteCallback> > request,
- bool compress_logs) {
+ bool compress_logs, bool add_feedback_context) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
if (request->canceled())
@@ -101,7 +106,8 @@ void SyslogsLibraryImpl::ReadSyslogs(
LogDictionaryType* logs = NULL;
if (CrosLibrary::Get()->EnsureLoaded())
logs = chromeos::GetSystemLogs(
- compress_logs ? &zip_file : NULL);
+ compress_logs ? &zip_file : NULL,
+ add_feedback_context ? kContextFeedback : kContextSysInfo);
std::string* zip_content = NULL;
if (compress_logs) {
@@ -131,4 +137,3 @@ void SyslogsLibraryImpl::LoadCompressedLogs(const FilePath& zip_file,
// Allows InvokeLater without adding refcounting. SyslogsLibraryImpl is a
// Singleton and won't be deleted until it's last InvokeLater is run.
DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::SyslogsLibraryImpl);
-
diff --git a/chrome/browser/chromeos/cros/syslogs_library.h b/chrome/browser/chromeos/cros/syslogs_library.h
index 3850a31..6b8c441 100644
--- a/chrome/browser/chromeos/cros/syslogs_library.h
+++ b/chrome/browser/chromeos/cros/syslogs_library.h
@@ -29,7 +29,7 @@ class SyslogsLibrary : public CancelableRequestProvider {
// Returns the request handle. Call CancelRequest(Handle) to cancel
// the request before the callback gets called.
virtual Handle RequestSyslogs(
- bool compress_logs,
+ bool compress_logs, bool feedback_context,
CancelableRequestConsumerBase* consumer,
ReadCompleteCallback* callback) = 0;
diff --git a/chrome/browser/chromeos/cros/system_library.cc b/chrome/browser/chromeos/cros/system_library.cc
index b14e38e..6c902b4 100644
--- a/chrome/browser/chromeos/cros/system_library.cc
+++ b/chrome/browser/chromeos/cros/system_library.cc
@@ -32,7 +32,7 @@ class SystemLibraryImpl : public SystemLibrary {
icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(id));
timezone_.reset(timezone);
icu::TimeZone::setDefault(*timezone);
- LOG(INFO) << "Timezone is " << id;
+ VLOG(1) << "Timezone is " << id;
}
void AddObserver(Observer* observer) {
@@ -54,7 +54,7 @@ class SystemLibraryImpl : public SystemLibrary {
timezone->getID(unicode);
std::string id;
UTF16ToUTF8(unicode.getBuffer(), unicode.length(), &id);
- LOG(INFO) << "Setting timezone to " << id;
+ VLOG(1) << "Setting timezone to " << id;
chromeos::SetTimezoneID(id);
}
icu::TimeZone::setDefault(*timezone);
diff --git a/chrome/browser/chromeos/cros/update_library.cc b/chrome/browser/chromeos/cros/update_library.cc
index 728cd4b..a201e0c 100644
--- a/chrome/browser/chromeos/cros/update_library.cc
+++ b/chrome/browser/chromeos/cros/update_library.cc
@@ -50,6 +50,20 @@ class UpdateLibraryImpl : public UpdateLibrary {
return RebootIfUpdated();
}
+ bool SetReleaseTrack(const std::string& track) {
+ if (!CrosLibrary::Get()->EnsureLoaded())
+ return false;
+
+ return chromeos::SetTrack(track);
+ }
+
+ std::string GetReleaseTrack() {
+ if (!CrosLibrary::Get()->EnsureLoaded())
+ return "";
+
+ return chromeos::GetTrack();
+ }
+
const UpdateLibrary::Status& status() const {
return status_;
}
@@ -107,6 +121,8 @@ class UpdateLibraryStubImpl : public UpdateLibrary {
void RemoveObserver(Observer* observer) {}
bool CheckForUpdate() { return false; }
bool RebootAfterUpdate() { return false; }
+ bool SetReleaseTrack(const std::string& track) { return false; }
+ std::string GetReleaseTrack() { return "beta-channel"; }
const UpdateLibrary::Status& status() const {
return status_;
}
diff --git a/chrome/browser/chromeos/cros/update_library.h b/chrome/browser/chromeos/cros/update_library.h
index 7b95815..e8a9daa 100644
--- a/chrome/browser/chromeos/cros/update_library.h
+++ b/chrome/browser/chromeos/cros/update_library.h
@@ -68,6 +68,14 @@ class UpdateLibrary {
// Reboots if update has been performed.
virtual bool RebootAfterUpdate() = 0;
+ // Sets the release track (channel). |track| should look like
+ // "beta-channel" and "dev-channel". Returns true on success.
+ virtual bool SetReleaseTrack(const std::string& track) = 0;
+
+ // Returns the release track (channel). On error, returns an empty
+ // string.
+ virtual std::string GetReleaseTrack() = 0;
+
virtual const Status& status() const = 0;
// Factory function, creates a new instance and returns ownership.
@@ -78,4 +86,3 @@ class UpdateLibrary {
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_CROS_UPDATE_LIBRARY_H_
-
generated by cgit v1.1 at 2025-11-06 23:53:43 +0000