project
string | commit_id
string | target
int64 | func
string | cwe
string | big_vul_idx
string | idx
int64 | hash
string | size
float64 | message
string | dataset
string |
|---|---|---|---|---|---|---|---|---|---|---|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 1
|
void UpdateNetworkManagerStatus() {
if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
NewRunnableMethod(this,
&NetworkLibraryImpl::UpdateNetworkManagerStatus));
return;
}
SystemInfo* system = GetSystemInfo();
if (!system)
return;
std::string prev_cellular_service_path = cellular_ ?
cellular_->service_path() : std::string();
ClearNetworks();
ParseSystem(system, ðernet_, &wifi_networks_, &cellular_networks_,
&remembered_wifi_networks_);
wifi_ = NULL;
for (size_t i = 0; i < wifi_networks_.size(); i++) {
if (wifi_networks_[i]->connecting_or_connected()) {
wifi_ = wifi_networks_[i];
break; // There is only one connected or connecting wifi network.
}
}
cellular_ = NULL;
for (size_t i = 0; i < cellular_networks_.size(); i++) {
if (cellular_networks_[i]->connecting_or_connected()) {
cellular_ = cellular_networks_[i];
if (cellular_networks_[i]->service_path() !=
prev_cellular_service_path) {
CellularDataPlanList* list = RetrieveCellularDataPlans(
cellular_->service_path().c_str());
UpdateCellularDataPlan(list);
FreeCellularDataPlanList(list);
}
break; // There is only one connected or connecting cellular network.
}
}
available_devices_ = system->available_technologies;
enabled_devices_ = system->enabled_technologies;
connected_devices_ = system->connected_technologies;
offline_mode_ = system->offline_mode;
NotifyNetworkManagerChanged();
FreeSystemInfo(system);
}
|
183616
| 4,681
|
176851565339666412051409584687167623341
| null | null | null |
|
Chrome
|
610f904d8215075c4681be4eb413f4348860bf9f
| 1
|
int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) {
HostUsageMap::const_iterator found = cached_usage_.find(host);
if (found == cached_usage_.end())
return 0;
int64 usage = 0;
const UsageMap& map = found->second;
for (UsageMap::const_iterator iter = map.begin();
iter != map.end(); ++iter) {
usage += iter->second;
}
return usage;
}
|
183644
| 4,706
|
81607632977134860466801081500022041763
| null | null | null |
|
Chrome
|
45bae236b03f577ed6682ef4c7ef3ee006de5e5a
| 1
|
void AddInstallerCopyTasks(const InstallerState& installer_state,
const FilePath& setup_path,
const FilePath& archive_path,
const FilePath& temp_path,
const Version& new_version,
WorkItemList* install_list) {
DCHECK(install_list);
FilePath installer_dir(installer_state.GetInstallerDirectory(new_version));
install_list->AddCreateDirWorkItem(installer_dir);
FilePath exe_dst(installer_dir.Append(setup_path.BaseName()));
FilePath archive_dst(installer_dir.Append(archive_path.BaseName()));
install_list->AddMoveTreeWorkItem(setup_path.value(), exe_dst.value(),
temp_path.value(), WorkItem::ALWAYS_MOVE);
install_list->AddMoveTreeWorkItem(archive_path.value(), archive_dst.value(),
temp_path.value(), WorkItem::ALWAYS_MOVE);
}
|
184084
| 5,095
|
296073909617636686988193993551614228480
| null | null | null |
|
Chrome
|
3c1864079c441ea2e08f882acaaf441f78a6de3d
| 1
|
bool decode(ArgumentDecoder* decoder, RetainPtr<CFURLRef>& result)
{
RetainPtr<CFURLRef> baseURL;
bool hasBaseURL;
if (!decoder->decodeBool(hasBaseURL))
return false;
if (hasBaseURL) {
if (!decode(decoder, baseURL))
return false;
}
RetainPtr<CFStringRef> string;
if (!decode(decoder, string))
return false;
CFURLRef url = CFURLCreateWithString(0, string.get(), baseURL.get());
if (!url)
return false;
result.adoptCF(url);
return true;
}
|
184202
| 5,194
|
130336217108486797871218257624771528040
| null | null | null |
|
Chrome
|
2bfb2b8299e2fb6a432390a93a99a85fed1d29c9
| 1
|
void WebProcessProxy::addExistingWebPage(WebPageProxy* webPage, uint64_t pageID)
{
m_pageMap.set(pageID, webPage);
globalPageMap().set(pageID, webPage);
#if PLATFORM(MAC)
if (pageIsProcessSuppressible(webPage));
m_processSuppressiblePages.add(pageID);
updateProcessSuppressionState();
#endif
}
|
184482
| 5,440
|
110522851826911328048375980316968416017
| null | null | null |
|
Chrome
|
6d067124e87295721c62a77f0610e4b37f6098ad
| 1
|
v8::Handle<v8::Value> V8ThrowException::createDOMException(v8::Isolate* isolate, int ec, const String& sanitizedMessage, const String& unsanitizedMessage, const v8::Handle<v8::Object>& creationContext)
{
if (ec <= 0 || v8::V8::IsExecutionTerminating())
return v8Undefined();
ASSERT(ec == SecurityError || unsanitizedMessage.isEmpty());
if (ec == V8GeneralError)
return V8ThrowException::createGeneralError(isolate, sanitizedMessage);
if (ec == V8TypeError)
return V8ThrowException::createTypeError(isolate, sanitizedMessage);
if (ec == V8RangeError)
return V8ThrowException::createRangeError(isolate, sanitizedMessage);
if (ec == V8SyntaxError)
return V8ThrowException::createSyntaxError(isolate, sanitizedMessage);
if (ec == V8ReferenceError)
return V8ThrowException::createReferenceError(isolate, sanitizedMessage);
RefPtrWillBeRawPtr<DOMException> domException = DOMException::create(ec, sanitizedMessage, unsanitizedMessage);
v8::Handle<v8::Value> exception = toV8(domException.get(), creationContext, isolate);
if (exception.IsEmpty())
return v8Undefined();
v8::Handle<v8::Value> error = v8::Exception::Error(v8String(isolate, domException->message()));
ASSERT(!error.IsEmpty());
ASSERT(exception->IsObject());
exception->ToObject(isolate)->SetAccessor(v8AtomicString(isolate, "stack"), domExceptionStackGetter, domExceptionStackSetter, error);
V8HiddenValue::setHiddenValue(isolate, exception->ToObject(isolate), V8HiddenValue::error(isolate), error);
return exception;
}
|
185956
| 6,754
|
165916481135831373002300240035909386676
| null | null | null |
|
Chrome
|
fb83de09f2c986ee91741f3a2776feea0e18e3f6
| 1
|
void OverlayWindowViews::OnGestureEvent(ui::GestureEvent* event) {
if (event->type() != ui::ET_GESTURE_TAP)
return;
hide_controls_timer_.Reset();
if (!GetControlsScrimLayer()->visible()) {
UpdateControlsVisibility(true);
return;
}
if (GetCloseControlsBounds().Contains(event->location())) {
controller_->Close(true /* should_pause_video */,
true /* should_reset_pip_player */);
event->SetHandled();
} else if (GetPlayPauseControlsBounds().Contains(event->location())) {
TogglePlayPause();
event->SetHandled();
}
views::Widget::OnGestureEvent(event);
}
|
186551
| 7,290
|
303506592678362065050884877503185093458
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
std::string CellularNetwork::ActivationStateToString(
ActivationState activation_state) {
switch (activation_state) {
case ACTIVATION_STATE_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATED);
break;
case ACTIVATION_STATE_ACTIVATING:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATING);
break;
case ACTIVATION_STATE_NOT_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED);
break;
case ACTIVATION_STATE_PARTIALLY_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_PARTIALLY_ACTIVATED);
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_UNKNOWN);
break;
}
}
|
100204
| 90,104
|
157999551299079595602783012275458877113
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void AddCellularDataPlanObserver(CellularDataPlanObserver* observer) {
if (!data_plan_observers_.HasObserver(observer))
data_plan_observers_.AddObserver(observer);
}
|
100205
| 90,105
|
309963211831686180665706939295472305039
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {
if (!network_manager_observers_.HasObserver(observer))
network_manager_observers_.AddObserver(observer);
}
|
100206
| 90,106
|
87001527718495044750268083261840873231
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {}
|
100207
| 90,107
|
42101612285565483690010476549071312560
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void AddNetworkObserver(const std::string& service_path,
NetworkObserver* observer) {
DCHECK(observer);
if (!EnsureCrosLoaded())
return;
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);
}
|
100208
| 90,108
|
155839336240772552856521786526032784186
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void AddNetworkObserver(const std::string& service_path,
NetworkObserver* observer) {}
|
100209
| 90,109
|
45531431629127569521371400434506842684
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
CellularNetwork::CellularNetwork()
: WirelessNetwork(),
activation_state_(ACTIVATION_STATE_UNKNOWN),
network_technology_(NETWORK_TECHNOLOGY_UNKNOWN),
roaming_state_(ROAMING_STATE_UNKNOWN),
restricted_pool_(false),
prl_version_(0) {
type_ = TYPE_CELLULAR;
}
|
100210
| 90,110
|
252380351537756827079597733078591804638
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
|
100211
| 90,111
|
167652839328409751861146595622280623032
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
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);
}
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;
}
|
100212
| 90,112
|
267750053852824637328044170290841582743
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void Network::Clear() {
state_ = STATE_UNKNOWN;
error_ = ERROR_UNKNOWN;
service_path_.clear();
device_path_.clear();
ip_address_.clear();
is_active_ = false;
}
|
100213
| 90,113
|
244571999020376687978447508599531047774
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void WirelessNetwork::Clear() {
Network::Clear();
name_.clear();
strength_ = 0;
auto_connect_ = false;
favorite_ = false;
}
|
100214
| 90,114
|
175615932126770035292404464450595702434
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void CellularNetwork::Clear() {
WirelessNetwork::Clear();
activation_state_ = ACTIVATION_STATE_UNKNOWN;
roaming_state_ = ROAMING_STATE_UNKNOWN;
network_technology_ = NETWORK_TECHNOLOGY_UNKNOWN;
restricted_pool_ = false;
service_name_.clear();
operator_name_.clear();
operator_code_.clear();
payment_url_.clear();
meid_.clear();
imei_.clear();
imsi_.clear();
esn_.clear();
mdn_.clear();
min_.clear();
model_id_.clear();
manufacturer_.clear();
firmware_revision_.clear();
hardware_revision_.clear();
last_update_.clear();
prl_version_ = 0;
}
|
100215
| 90,115
|
186556904507780151535559211245330379193
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void WifiNetwork::Clear() {
WirelessNetwork::Clear();
encryption_ = SECURITY_NONE;
passphrase_.clear();
identity_.clear();
cert_path_.clear();
}
|
100216
| 90,116
|
318898463832164494496758719947387970905
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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();
}
|
100217
| 90,117
|
100738864938815938949255162727268172419
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void ConnectToWifiNetwork(const WifiNetwork* network,
const std::string& password,
const std::string& identity,
const std::string& certpath) {
DCHECK(network);
if (!EnsureCrosLoaded())
return;
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())) {
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();
}
}
|
100220
| 90,118
|
15685958005356315142055036861470092720
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void ConnectToWifiNetwork(ConnectionSecurity security,
const std::string& ssid,
const std::string& password,
const std::string& identity,
const std::string& certpath,
bool auto_connect) {
if (!EnsureCrosLoaded())
return;
ServiceInfo* service = GetWifiService(ssid.c_str(), security);
if (service) {
SetAutoConnect(service->service_path, auto_connect);
ConnectToNetworkWithCertInfo(service->service_path,
password.empty() ? NULL : password.c_str(),
identity.empty() ? NULL : identity.c_str(),
certpath.empty() ? NULL : certpath.c_str());
FreeServiceInfo(service);
} else {
LOG(WARNING) << "Cannot find hidden network: " << ssid;
}
}
|
100221
| 90,119
|
200790263612330962385368027947917410629
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void ConnectToWifiNetwork(const WifiNetwork* network,
const std::string& password,
const std::string& identity,
const std::string& certpath) {}
|
100222
| 90,120
|
262656762509779546039061619870740592916
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void ConnectToWifiNetwork(ConnectionSecurity security,
const std::string& ssid,
const std::string& password,
const std::string& identity,
const std::string& certpath,
bool auto_connect) {}
|
100223
| 90,121
|
6707875500153624124655977289587329099
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
bool Connected() const {
return ethernet_connected() || wifi_connected() || cellular_connected();
}
|
100224
| 90,122
|
186253347372044473031316286851156345047
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
bool Connected() const { return true; }
|
100225
| 90,123
|
146011116526572789061152536462200738837
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
bool Connecting() const {
return ethernet_connecting() || wifi_connecting() || cellular_connecting();
}
|
100226
| 90,124
|
183209889232426848387724540393569800353
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
bool Connecting() const { return false; }
|
100227
| 90,125
|
225410887447383169752678129476690049671
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {
DCHECK(network);
if (!EnsureCrosLoaded() || !network)
return;
if (DisconnectFromNetwork(network->service_path().c_str())) {
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;
}
}
NotifyNetworkManagerChanged();
}
}
|
100229
| 90,126
|
206941887053772269686805518431414489437
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {}
|
100230
| 90,127
|
266455875333630270384089647731569112707
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void EnableCellularNetworkDevice(bool enable) {
EnableNetworkDeviceType(TYPE_CELLULAR, enable);
}
|
100231
| 90,128
|
61589371471429597435607274070303664472
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void EnableEthernetNetworkDevice(bool enable) {
EnableNetworkDeviceType(TYPE_ETHERNET, enable);
}
|
100233
| 90,129
|
84254815677886177831832712432794013605
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void EnableEthernetNetworkDevice(bool enable) {}
|
100234
| 90,130
|
274671827729876532508071326219645317041
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void EnableNetworkDeviceType(ConnectionType device, bool enable) {
if (!EnsureCrosLoaded())
return;
if (enable && (enabled_devices_ & (1 << device))) {
LOG(WARNING) << "Trying to enable a device that's already enabled: "
<< device;
return;
}
if (!enable && !(enabled_devices_ & (1 << device))) {
LOG(WARNING) << "Trying to disable a device that's already disabled: "
<< device;
return;
}
EnableNetworkDevice(device, enable);
}
|
100235
| 90,131
|
107957117492822003232975999681691493975
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void EnableOfflineMode(bool enable) {
if (!EnsureCrosLoaded())
return;
if (enable && offline_mode_) {
VLOG(1) << "Trying to enable offline mode when it's already enabled.";
return;
}
if (!enable && !offline_mode_) {
VLOG(1) << "Trying to disable offline mode when it's already disabled.";
return;
}
if (SetOfflineMode(enable)) {
offline_mode_ = enable;
}
}
|
100236
| 90,132
|
135406634521258702153013213647483120094
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void EnableOfflineMode(bool enable) {}
|
100237
| 90,133
|
46899092895460312038724768261213276710
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void EnableWifiNetworkDevice(bool enable) {
EnableNetworkDeviceType(TYPE_WIFI, enable);
}
|
100238
| 90,134
|
11803922121700414865976478735405877412
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual CellularNetwork* FindCellularNetworkByPath(
const std::string& path) { return NULL; }
|
100242
| 90,135
|
169727144667576244060636458569764624984
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual WifiNetwork* FindWifiNetworkByPath(
const std::string& path) {
return GetWirelessNetworkByPath(wifi_networks_, path);
}
|
100243
| 90,136
|
208250587198073239598113354489423397552
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual WifiNetwork* FindWifiNetworkByPath(
const std::string& path) { return NULL; }
|
100244
| 90,137
|
137353046969598023496203562144449106790
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void ForgetWifiNetwork(const std::string& service_path) {
if (!EnsureCrosLoaded())
return;
if (DeleteRememberedService(service_path.c_str())) {
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();
}
}
|
100245
| 90,138
|
172150592111709056096815297096246337263
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
std::string CellularNetwork::GetActivationStateString() const {
return ActivationStateToString(this->activation_state_);
}
|
100247
| 90,139
|
229737994156723362985251717887716369331
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
std::string WifiNetwork::GetEncryptionString() {
switch (encryption_) {
case SECURITY_UNKNOWN:
break;
case SECURITY_NONE:
return "";
case SECURITY_WEP:
return "WEP";
case SECURITY_WPA:
return "WPA";
case SECURITY_RSN:
return "RSN";
case SECURITY_8021X:
return "8021X";
}
return "Unknown";
}
|
100248
| 90,140
|
327494090980129871900814097035373985360
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
std::string Network::GetErrorString() const {
switch (error_) {
case ERROR_UNKNOWN:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
case ERROR_OUT_OF_RANGE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_OUT_OF_RANGE);
case ERROR_PIN_MISSING:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_PIN_MISSING);
case ERROR_DHCP_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_DHCP_FAILED);
case ERROR_CONNECT_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_CONNECT_FAILED);
case ERROR_BAD_PASSPHRASE:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_BAD_PASSPHRASE);
case ERROR_BAD_WEPKEY:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_BAD_WEPKEY);
case ERROR_ACTIVATION_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_ACTIVATION_FAILED);
case ERROR_NEED_EVDO:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_NEED_EVDO);
case ERROR_NEED_HOME_NETWORK:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_NEED_HOME_NETWORK);
case ERROR_OTASP_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_OTASP_FAILED);
case ERROR_AAA_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_AAA_FAILED);
default:
break;
}
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
}
|
100249
| 90,141
|
90387433064655559862207825115909648697
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual std::string GetHtmlInfo(int refresh) {
std::string output;
output.append("<html><head><title>About Network</title>");
if (refresh > 0)
output.append("<meta http-equiv=\"refresh\" content=\"" +
base::IntToString(refresh) + "\"/>");
output.append("</head><body>");
if (refresh > 0) {
output.append("(Auto-refreshing page every " +
base::IntToString(refresh) + "s)");
} else {
output.append("(To auto-refresh this page: about:network/<secs>)");
}
output.append("<h3>Ethernet:</h3><table border=1>");
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("</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]) +
"</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>");
output.append("<tr>" + ToHtmlTableRow(remembered_wifi_networks_[i]) +
"</tr>");
}
output.append("</table></body></html>");
return output;
}
|
100250
| 90,142
|
142770398384310073293835235988098047483
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual std::string GetHtmlInfo(int refresh) { return std::string(); }
|
100251
| 90,143
|
66925089768019925140231724655329202898
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual NetworkIPConfigVector GetIPConfigs(const std::string& device_path,
std::string* hardware_address) {
hardware_address->clear();
NetworkIPConfigVector ipconfig_vector;
if (EnsureCrosLoaded() && !device_path.empty()) {
IPConfigStatus* ipconfig_status = ListIPConfigs(device_path.c_str());
if (ipconfig_status) {
for (int i = 0; i < ipconfig_status->size; i++) {
IPConfig ipconfig = ipconfig_status->ips[i];
ipconfig_vector.push_back(
NetworkIPConfig(device_path, ipconfig.type, ipconfig.address,
ipconfig.netmask, ipconfig.gateway,
ipconfig.name_servers));
}
*hardware_address = ipconfig_status->hardware_address;
FreeIPConfigStatus(ipconfig_status);
std::sort(ipconfig_vector.begin(), ipconfig_vector.end());
}
}
return ipconfig_vector;
}
|
100252
| 90,144
|
140283104987390884386890026908528199718
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual NetworkIPConfigVector GetIPConfigs(const std::string& device_path,
std::string* hardware_address) {
hardware_address->clear();
return NetworkIPConfigVector();
}
|
100253
| 90,145
|
271187531437847626523649610335869410321
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
NetworkLibrary* NetworkLibrary::GetImpl(bool stub) {
if (stub)
return new NetworkLibraryStubImpl();
else
return new NetworkLibraryImpl();
}
|
100254
| 90,146
|
9082810096392208570408210979217450220
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
std::string CellularNetwork::GetRoamingStateString() const {
switch (this->roaming_state_) {
case ROAMING_STATE_HOME:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_HOME);
break;
case ROAMING_STATE_ROAMING:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_ROAMING);
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_UNKNOWN);
break;
};
}
|
100256
| 90,147
|
72467369506769717092083373186802673469
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
std::string Network::GetStateString() const {
switch (state_) {
case STATE_UNKNOWN:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNKNOWN);
case STATE_IDLE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_IDLE);
case STATE_CARRIER:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CARRIER);
case STATE_ASSOCIATION:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ASSOCIATION);
case STATE_CONFIGURATION:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CONFIGURATION);
case STATE_READY:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_READY);
case STATE_DISCONNECT:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_DISCONNECT);
case STATE_FAILURE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_FAILURE);
case STATE_ACTIVATION_FAILURE:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_STATE_ACTIVATION_FAILURE);
default:
break;
}
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
}
|
100257
| 90,148
|
236088130014265375580788110944577340295
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) {
if (!EnsureCrosLoaded())
return false;
DeviceNetworkList* network_list = GetDeviceNetworkList();
if (network_list == NULL)
return false;
result->clear();
result->reserve(network_list->network_size);
const base::Time now = base::Time::Now();
for (size_t i = 0; i < network_list->network_size; ++i) {
DCHECK(network_list->networks[i].address);
DCHECK(network_list->networks[i].name);
WifiAccessPoint ap;
ap.mac_address = SafeString(network_list->networks[i].address);
ap.name = SafeString(network_list->networks[i].name);
ap.timestamp = now -
base::TimeDelta::FromSeconds(network_list->networks[i].age_seconds);
ap.signal_strength = network_list->networks[i].strength;
ap.channel = network_list->networks[i].channel;
result->push_back(ap);
}
FreeDeviceNetworkList(network_list);
return true;
}
|
100258
| 90,149
|
331136930360542672624148076920600155951
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) {
return false;
}
|
100259
| 90,150
|
169181197170185483620298714421309974470
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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];
}
}
return NULL;
}
|
100260
| 90,151
|
73544466230153682261995075015447722214
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
|
100261
| 90,152
|
112041072654314796205064754415290612968
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
|
100262
| 90,153
|
311275032166277241385568275723465014260
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
const std::string& IPAddress() const {
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;
}
|
100263
| 90,154
|
175578860822119675295487810040318228651
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
const std::string& IPAddress() const { return ip_address_; }
|
100264
| 90,155
|
112572501574773710308430208778388548631
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void Init() {
VLOG(1) << "Getting initial CrOS network info.";
UpdateSystemInfo();
}
|
100265
| 90,156
|
18821535876858130091201121271351724462
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void InitTestData() {
ethernet_ = new EthernetNetwork();
ethernet_->set_connected(true);
ethernet_->set_service_path("eth1");
STLDeleteElements(&wifi_networks_);
wifi_networks_.clear();
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 = 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 = 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();
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);
cellular_ = cellular1;
remembered_wifi_networks_.clear();
remembered_wifi_networks_.push_back(new WifiNetwork(*wifi2));
int devices = (1 << TYPE_ETHERNET) | (1 << TYPE_WIFI) |
(1 << TYPE_CELLULAR);
available_devices_ = devices;
enabled_devices_ = devices;
connected_devices_ = devices;
offline_mode_ = false;
}
|
100266
| 90,157
|
167100198236684029863041891519429049805
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
bool WifiNetwork::IsCertificateLoaded() const {
static const std::string settings_string("SETTINGS:");
static const std::string pkcs11_key("key_id");
if (cert_path_.find(settings_string) == 0) {
std::string::size_type idx = cert_path_.find(pkcs11_key);
if (idx != std::string::npos)
idx = cert_path_.find_first_not_of(kWhitespaceASCII,
idx + pkcs11_key.length());
if (idx != std::string::npos && cert_path_[idx] == '=')
return true;
}
return false;
}
|
100267
| 90,158
|
132690335736935728948742779437175557994
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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();
}
|
100268
| 90,159
|
79820405273639067626751173570153768379
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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 (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];
if (strlen(ipconfig.address) > 0)
ip_address_ = ipconfig.address;
}
FreeIPConfigStatus(ipconfig_status);
}
}
}
|
100269
| 90,160
|
115211557826920068666282813044348220689
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
NetworkLibraryImpl()
: 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) {
if (EnsureCrosLoaded()) {
Init();
network_manager_monitor_ =
MonitorNetworkManager(&NetworkManagerStatusChangedHandler,
this);
data_plan_monitor_ = MonitorCellularDataPlan(&DataPlanUpdateHandler,
this);
} else {
InitTestData();
}
}
|
100270
| 90,161
|
143922874751952932618520217243251316994
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
NetworkObserverList(NetworkLibraryImpl* library,
const std::string& service_path) {
network_monitor_ = MonitorNetworkService(&NetworkStatusChangedHandler,
service_path.c_str(),
library);
}
|
100273
| 90,162
|
286359904974810435114420047143325166709
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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);
}
|
100274
| 90,163
|
156818042270159240803621782352740583177
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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();
}
}
|
100276
| 90,164
|
250190812877619623108397662051110321846
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
|
100278
| 90,165
|
2263283871812024506837222820762880493
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
|
100279
| 90,166
|
70423057784816375318496886225400622269
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
|
100280
| 90,167
|
169360571090743759335727748954157843372
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
|
100281
| 90,168
|
251788502362499443908390417562018916699
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
static void ParseSystem(SystemInfo* system,
EthernetNetwork** ethernet,
WifiNetworkVector* wifi_networks,
CellularNetworkVector* cellular_networks,
WifiNetworkVector* remembered_wifi_networks) {
DVLOG(1) << "ParseSystem:";
DCHECK(!(*ethernet));
for (int i = 0; i < system->service_size; i++) {
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;
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));
}
}
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);
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));
}
}
}
}
|
100282
| 90,169
|
139591473638713483225834677538000176518
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RefreshCellularDataPlans(const CellularNetwork* network) {
DCHECK(network);
if (!EnsureCrosLoaded() || !network)
return;
RequestCellularDataPlanUpdate(network->service_path().c_str());
}
|
100283
| 90,170
|
192023471038669764462312151482168767035
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RefreshCellularDataPlans(const CellularNetwork* network) {}
|
100284
| 90,171
|
1344039349509197250511103621414184218
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RemoveCellularDataPlanObserver(
CellularDataPlanObserver* observer) {
data_plan_observers_.RemoveObserver(observer);
}
|
100285
| 90,172
|
128012247756471413099948233504593029179
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RemoveCellularDataPlanObserver(
CellularDataPlanObserver* observer) {}
|
100286
| 90,173
|
326605952219915541290676799521107486709
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {
network_manager_observers_.RemoveObserver(observer);
}
|
100287
| 90,174
|
84021511120076170317381110119111726128
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {}
|
100288
| 90,175
|
188078969887004784933846867006847293478
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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++);
}
}
}
|
100289
| 90,176
|
336457699653405749829736007091205651060
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RemoveNetworkObserver(const std::string& service_path,
NetworkObserver* observer) {}
|
100290
| 90,177
|
265584246525361761487834738573697965315
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
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;
}
}
}
|
100291
| 90,178
|
132020087194084352171344353105175776893
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {}
|
100292
| 90,179
|
335871092068222919601041216359378500853
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RequestWifiScan() {
if (EnsureCrosLoaded()) {
RequestScan(TYPE_WIFI);
}
}
|
100293
| 90,180
|
158605175287867623724443683482048266773
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void RequestWifiScan() {}
|
100294
| 90,181
|
133494885761794120629418394600028454305
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
static std::string SafeString(const char* s) {
return s ? std::string(s) : std::string();
}
|
100295
| 90,182
|
256469361676011650220103312527764840555
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void SaveCellularNetwork(const CellularNetwork* network) {
DCHECK(network);
if (!EnsureCrosLoaded() || !network)
return;
SetAutoConnect(network->service_path().c_str(), network->auto_connect());
}
|
100296
| 90,183
|
18052166127905443907886215124543640249
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void SaveCellularNetwork(const CellularNetwork* network) {}
|
100297
| 90,184
|
290365002596864568049132297052182761427
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void SaveWifiNetwork(const WifiNetwork* network) {
DCHECK(network);
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());
}
|
100298
| 90,185
|
187762036778343741480065721462308461509
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
virtual void SaveWifiNetwork(const WifiNetwork* network) {}
|
100299
| 90,186
|
60417940634069856342372753963354729577
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
bool CellularNetwork::StartActivation() const {
if (!EnsureCrosLoaded())
return false;
return ActivateCellularModem(service_path_.c_str(), NULL);
}
|
100300
| 90,187
|
29134216652527605034546796435589062062
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
static std::string ToHtmlTableHeader(Network* network) {
std::string str;
if (network->type() == TYPE_WIFI || network->type() == TYPE_CELLULAR) {
str += WrapWithTH("Name") + WrapWithTH("Auto-Connect") +
WrapWithTH("Strength");
if (network->type() == TYPE_WIFI)
str += WrapWithTH("Encryption") + WrapWithTH("Passphrase") +
WrapWithTH("Identity") + WrapWithTH("Certificate");
}
str += WrapWithTH("State") + WrapWithTH("Error") + WrapWithTH("IP Address");
return str;
}
|
100301
| 90,188
|
28300095032241660466710277877439715114
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
static std::string ToHtmlTableRow(Network* network) {
std::string str;
if (network->type() == TYPE_WIFI || network->type() == TYPE_CELLULAR) {
WirelessNetwork* wireless = static_cast<WirelessNetwork*>(network);
str += WrapWithTD(wireless->name()) +
WrapWithTD(base::IntToString(wireless->auto_connect())) +
WrapWithTD(base::IntToString(wireless->strength()));
if (network->type() == TYPE_WIFI) {
WifiNetwork* wifi = static_cast<WifiNetwork*>(network);
str += WrapWithTD(wifi->GetEncryptionString()) +
WrapWithTD(std::string(wifi->passphrase().length(), '*')) +
WrapWithTD(wifi->identity()) + WrapWithTD(wifi->cert_path());
}
}
str += WrapWithTD(network->GetStateString()) +
WrapWithTD(network->failed() ? network->GetErrorString() : "") +
WrapWithTD(network->ip_address());
return str;
}
|
100302
| 90,189
|
235327246348549741713310867075211976376
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void UpdateCellularDataPlan(const CellularDataPlanList* data_plans) {
DCHECK(cellular_);
cellular_->SetDataPlans(data_plans);
NotifyCellularDataPlanChanged();
}
|
100303
| 90,190
|
60042064533955413446770488547406494975
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void UpdateNetworkStatus(const char* path,
const char* key,
const Value* value) {
if (key == NULL || value == NULL)
return;
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);
}
|
100304
| 90,191
|
202171820087218295250180860651225849540
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
void UpdateSystemInfo() {
if (EnsureCrosLoaded()) {
UpdateNetworkManagerStatus();
}
}
|
100305
| 90,192
|
296030291345733783356589835512482813346
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
WifiNetwork::WifiNetwork()
: WirelessNetwork(),
encryption_(SECURITY_NONE) {
type_ = TYPE_WIFI;
}
|
100307
| 90,193
|
218491153610312572633321573714082095111
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
WifiNetwork::WifiNetwork(const WifiNetwork& network)
: WirelessNetwork(network) {
encryption_ = network.encryption();
passphrase_ = network.passphrase();
identity_ = network.identity();
cert_path_ = network.cert_path();
}
|
100308
| 90,194
|
25337486204639895975858093365695802736
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
WirelessNetwork::WirelessNetwork(const WirelessNetwork& network)
: Network(network) {
name_ = network.name();
strength_ = network.strength();
auto_connect_ = network.auto_connect();
favorite_ = network.favorite();
}
|
100310
| 90,195
|
272714074412331977900264541901799847304
| null | null | null |
|
Chrome
|
a3e2afaedd8190398ae45ccef34fcdee00fb19aa
| 0
|
WirelessNetwork::WirelessNetwork(const ServiceInfo* service)
: Network(service) {
name_ = SafeString(service->name);
strength_ = service->strength;
auto_connect_ = service->auto_connect;
favorite_ = service->favorite;
}
|
100311
| 90,196
|
294814854141559750146399729545177466489
| null | null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.