OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/automation/testing_automation_provider.h" | 5 #include "chrome/browser/automation/testing_automation_provider.h" |
6 | 6 |
7 #include "ash/shell.h" | 7 #include "ash/shell.h" |
8 #include "ash/shell_delegate.h" | 8 #include "ash/shell_delegate.h" |
9 #include "ash/system/tray/system_tray_delegate.h" | 9 #include "ash/system/tray/system_tray_delegate.h" |
10 #include "base/command_line.h" | 10 #include "base/command_line.h" |
(...skipping 614 matching lines...) Loading... |
625 network_library->EnableWifiNetworkDevice(enable); | 625 network_library->EnableWifiNetworkDevice(enable); |
626 } else if (device == "cellular") { | 626 } else if (device == "cellular") { |
627 network_library->EnableCellularNetworkDevice(enable); | 627 network_library->EnableCellularNetworkDevice(enable); |
628 } else { | 628 } else { |
629 reply.SendError( | 629 reply.SendError( |
630 "Unknown device. Valid devices are ethernet, wifi, cellular."); | 630 "Unknown device. Valid devices are ethernet, wifi, cellular."); |
631 return; | 631 return; |
632 } | 632 } |
633 } | 633 } |
634 | 634 |
635 void TestingAutomationProvider::SetSharedProxies( | |
636 DictionaryValue* args, | |
637 IPC::Message* reply_message) { | |
638 | |
639 AutomationJSONReply reply(this, reply_message); | |
640 base::Value* value; | |
641 if (!args->Get("value", &value)) { | |
642 reply.SendError("Invalid or missing value argument."); | |
643 return; | |
644 } | |
645 std::string error_message; | |
646 Profile* profile = | |
647 automation_util::GetCurrentProfileOnChromeOS(&error_message); | |
648 if (!profile) { | |
649 reply.SendError(error_message); | |
650 return; | |
651 } | |
652 PrefService* pref_service = profile->GetPrefs(); | |
653 pref_service->Set(prefs::kUseSharedProxies, *value); | |
654 reply.SendSuccess(NULL); | |
655 } | |
656 | |
657 void TestingAutomationProvider::SetProxySettings(DictionaryValue* args, | |
658 IPC::Message* reply_message) { | |
659 AutomationJSONReply reply(this, reply_message); | |
660 std::string proxy_config_str; | |
661 if (!args->GetString("proxy_config", &proxy_config_str)) { | |
662 reply.SendError("Invalid or missing args."); | |
663 return; | |
664 } | |
665 | |
666 const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()-> | |
667 network_state_handler()->DefaultNetwork(); | |
668 if (!network) { | |
669 reply.SendError("No network connected."); | |
670 return; | |
671 } | |
672 | |
673 scoped_ptr<base::DictionaryValue> proxy_config_dict( | |
674 chromeos::onc::ReadDictionaryFromJson(proxy_config_str)); | |
675 ProxyConfigDictionary proxy_config(proxy_config_dict.get()); | |
676 chromeos::proxy_config::SetProxyConfigForNetwork(proxy_config, *network); | |
677 | |
678 reply.SendSuccess(NULL); | |
679 } | |
680 | |
681 void TestingAutomationProvider::ConnectToCellularNetwork( | |
682 DictionaryValue* args, IPC::Message* reply_message) { | |
683 std::string service_path; | |
684 if (!args->GetString("service_path", &service_path)) { | |
685 AutomationJSONReply(this, reply_message).SendError( | |
686 "Invalid or missing args."); | |
687 return; | |
688 } | |
689 | |
690 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
691 chromeos::CellularNetwork* cellular = | |
692 network_library->FindCellularNetworkByPath(service_path); | |
693 if (!cellular) { | |
694 AutomationJSONReply(this, reply_message).SendError( | |
695 "No network found with specified service path."); | |
696 return; | |
697 } | |
698 | |
699 // Set up an observer (it will delete itself). | |
700 new ServicePathConnectObserver(this, reply_message, service_path); | |
701 | |
702 network_library->ConnectToCellularNetwork(cellular); | |
703 network_library->RequestNetworkScan(); | |
704 } | |
705 | |
706 void TestingAutomationProvider::DisconnectFromCellularNetwork( | |
707 DictionaryValue* args, IPC::Message* reply_message) { | |
708 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
709 const chromeos::CellularNetwork* cellular = | |
710 network_library->cellular_network(); | |
711 if (!cellular) { | |
712 AutomationJSONReply(this, reply_message).SendError( | |
713 "Not connected to any cellular network."); | |
714 return; | |
715 } | |
716 | |
717 // Set up an observer (it will delete itself). | |
718 new NetworkDisconnectObserver(this, reply_message, cellular->service_path()); | |
719 | |
720 network_library->DisconnectFromNetwork(cellular); | |
721 } | |
722 | |
723 void TestingAutomationProvider::ConnectToWifiNetwork( | |
724 DictionaryValue* args, IPC::Message* reply_message) { | |
725 AutomationJSONReply reply(this, reply_message); | |
726 std::string service_path, password; | |
727 bool shared; | |
728 if (!args->GetString("service_path", &service_path) || | |
729 !args->GetString("password", &password) || | |
730 !args->GetBoolean("shared", &shared)) { | |
731 reply.SendError("Invalid or missing args."); | |
732 return; | |
733 } | |
734 | |
735 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
736 chromeos::WifiNetwork* wifi = | |
737 network_library->FindWifiNetworkByPath(service_path); | |
738 if (!wifi) { | |
739 reply.SendError("No network found with specified service path."); | |
740 return; | |
741 } | |
742 if (!password.empty()) | |
743 wifi->SetPassphrase(password); | |
744 | |
745 // Regardless of what was passed, if the network is open and visible, | |
746 // the network must be shared because of a UI restriction. | |
747 if (wifi->encryption() == chromeos::SECURITY_NONE) | |
748 shared = true; | |
749 | |
750 // Set up an observer (it will delete itself). | |
751 new ServicePathConnectObserver(this, reply_message, service_path); | |
752 | |
753 network_library->ConnectToWifiNetwork(wifi, shared); | |
754 network_library->RequestNetworkScan(); | |
755 } | |
756 | |
757 void TestingAutomationProvider::ForgetWifiNetwork( | 635 void TestingAutomationProvider::ForgetWifiNetwork( |
758 DictionaryValue* args, IPC::Message* reply_message) { | 636 DictionaryValue* args, IPC::Message* reply_message) { |
759 std::string service_path; | 637 std::string service_path; |
760 if (!args->GetString("service_path", &service_path)) { | 638 if (!args->GetString("service_path", &service_path)) { |
761 AutomationJSONReply(this, reply_message).SendError( | 639 AutomationJSONReply(this, reply_message).SendError( |
762 "Invalid or missing args."); | 640 "Invalid or missing args."); |
763 return; | 641 return; |
764 } | 642 } |
765 | 643 |
766 NetworkLibrary::Get()->ForgetNetwork(service_path); | 644 NetworkLibrary::Get()->ForgetNetwork(service_path); |
(...skipping 85 matching lines...) Loading... |
852 network_library->ConnectToUnconfiguredWifiNetwork( | 730 network_library->ConnectToUnconfiguredWifiNetwork( |
853 ssid, chromeos::SECURITY_8021X, password, &config_data, | 731 ssid, chromeos::SECURITY_8021X, password, &config_data, |
854 save_credentials, shared); | 732 save_credentials, shared); |
855 } else { | 733 } else { |
856 network_library->ConnectToUnconfiguredWifiNetwork( | 734 network_library->ConnectToUnconfiguredWifiNetwork( |
857 ssid, connection_security, password, NULL, | 735 ssid, connection_security, password, NULL, |
858 save_credentials, shared); | 736 save_credentials, shared); |
859 } | 737 } |
860 } | 738 } |
861 | 739 |
862 void TestingAutomationProvider::DisconnectFromWifiNetwork( | |
863 DictionaryValue* args, IPC::Message* reply_message) { | |
864 AutomationJSONReply reply(this, reply_message); | |
865 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
866 const chromeos::WifiNetwork* wifi = network_library->wifi_network(); | |
867 if (!wifi) { | |
868 reply.SendError("Not connected to any wifi network."); | |
869 return; | |
870 } | |
871 | |
872 network_library->DisconnectFromNetwork(wifi); | |
873 reply.SendSuccess(NULL); | |
874 } | |
875 | |
876 void TestingAutomationProvider::AddPrivateNetwork( | |
877 DictionaryValue* args, IPC::Message* reply_message) { | |
878 std::string hostname, service_name, provider_type, key, cert_id, username, | |
879 password; | |
880 if (!args->GetString("hostname", &hostname) || | |
881 !args->GetString("service_name", &service_name) || | |
882 !args->GetString("provider_type", &provider_type) || | |
883 !args->GetString("username", &username) || | |
884 !args->GetString("password", &password)) { | |
885 AutomationJSONReply(this, reply_message) | |
886 .SendError("Invalid or missing args."); | |
887 return; | |
888 } | |
889 | |
890 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
891 | |
892 // Attempt to connect to the VPN based on the provider type. | |
893 if (provider_type == VPNProviderTypeToString( | |
894 chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK)) { | |
895 if (!args->GetString("key", &key)) { | |
896 AutomationJSONReply(this, reply_message) | |
897 .SendError("Missing key arg."); | |
898 return; | |
899 } | |
900 new VirtualConnectObserver(this, reply_message, service_name); | |
901 // Connect using a pre-shared key. | |
902 chromeos::NetworkLibrary::VPNConfigData config_data; | |
903 config_data.psk = key; | |
904 config_data.username = username; | |
905 config_data.user_passphrase = password; | |
906 network_library->ConnectToUnconfiguredVirtualNetwork( | |
907 service_name, | |
908 hostname, | |
909 chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK, | |
910 config_data); | |
911 } else if (provider_type == VPNProviderTypeToString( | |
912 chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT)) { | |
913 if (!args->GetString("cert_id", &cert_id)) { | |
914 AutomationJSONReply(this, reply_message) | |
915 .SendError("Missing a certificate arg."); | |
916 return; | |
917 } | |
918 new VirtualConnectObserver(this, reply_message, service_name); | |
919 // Connect using a user certificate. | |
920 chromeos::NetworkLibrary::VPNConfigData config_data; | |
921 config_data.client_cert_pkcs11_id = cert_id; | |
922 config_data.username = username; | |
923 config_data.user_passphrase = password; | |
924 network_library->ConnectToUnconfiguredVirtualNetwork( | |
925 service_name, | |
926 hostname, | |
927 chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT, | |
928 config_data); | |
929 } else if (provider_type == VPNProviderTypeToString( | |
930 chromeos::PROVIDER_TYPE_OPEN_VPN)) { | |
931 std::string otp; | |
932 args->GetString("otp", &otp); | |
933 // Connect using OPEN_VPN. | |
934 chromeos::NetworkLibrary::VPNConfigData config_data; | |
935 config_data.client_cert_pkcs11_id = cert_id; | |
936 config_data.username = username; | |
937 config_data.user_passphrase = password; | |
938 config_data.otp = otp; | |
939 network_library->ConnectToUnconfiguredVirtualNetwork( | |
940 service_name, | |
941 hostname, | |
942 chromeos::PROVIDER_TYPE_OPEN_VPN, | |
943 config_data); | |
944 } else { | |
945 AutomationJSONReply(this, reply_message) | |
946 .SendError("Unsupported provider type."); | |
947 return; | |
948 } | |
949 } | |
950 | |
951 void TestingAutomationProvider::ConnectToPrivateNetwork( | |
952 DictionaryValue* args, IPC::Message* reply_message) { | |
953 AutomationJSONReply reply(this, reply_message); | |
954 std::string service_path; | |
955 if (!args->GetString("service_path", &service_path)) { | |
956 reply.SendError("Invalid or missing args."); | |
957 return; | |
958 } | |
959 | |
960 // Connect to a remembered VPN by its service_path. Valid service_paths | |
961 // can be found in the dictionary returned by GetPrivateNetworkInfo. | |
962 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
963 chromeos::VirtualNetwork* network = | |
964 network_library->FindVirtualNetworkByPath(service_path); | |
965 if (!network) { | |
966 reply.SendError(base::StringPrintf("No virtual network found: %s", | |
967 service_path.c_str())); | |
968 return; | |
969 } | |
970 if (network->NeedMoreInfoToConnect()) { | |
971 reply.SendError("Virtual network is missing info required to connect."); | |
972 return; | |
973 }; | |
974 | |
975 // Set up an observer (it will delete itself). | |
976 new VirtualConnectObserver(this, reply_message, network->name()); | |
977 network_library->ConnectToVirtualNetwork(network); | |
978 } | |
979 | |
980 void TestingAutomationProvider::GetPrivateNetworkInfo( | |
981 DictionaryValue* args, IPC::Message* reply_message) { | |
982 scoped_ptr<DictionaryValue> return_value(new DictionaryValue); | |
983 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
984 const chromeos::VirtualNetworkVector& virtual_networks = | |
985 network_library->virtual_networks(); | |
986 | |
987 // Construct a dictionary of fields describing remembered VPNs. Also list | |
988 // the currently active VPN, if any. | |
989 if (network_library->virtual_network()) | |
990 return_value->SetString("connected", | |
991 network_library->virtual_network()->service_path()); | |
992 for (chromeos::VirtualNetworkVector::const_iterator iter = | |
993 virtual_networks.begin(); iter != virtual_networks.end(); ++iter) { | |
994 const chromeos::VirtualNetwork* virt = *iter; | |
995 DictionaryValue* item = new DictionaryValue; | |
996 item->SetString("name", virt->name()); | |
997 item->SetString("provider_type", | |
998 VPNProviderTypeToString(virt->provider_type())); | |
999 item->SetString("hostname", virt->server_hostname()); | |
1000 item->SetString("key", virt->psk_passphrase()); | |
1001 item->SetString("cert_id", virt->client_cert_id()); | |
1002 item->SetString("username", virt->username()); | |
1003 item->SetString("password", virt->user_passphrase()); | |
1004 return_value->Set(virt->service_path(), item); | |
1005 } | |
1006 | |
1007 AutomationJSONReply(this, reply_message).SendSuccess(return_value.get()); | |
1008 } | |
1009 | |
1010 void TestingAutomationProvider::DisconnectFromPrivateNetwork( | |
1011 DictionaryValue* args, IPC::Message* reply_message) { | |
1012 AutomationJSONReply reply(this, reply_message); | |
1013 NetworkLibrary* network_library = NetworkLibrary::Get(); | |
1014 const chromeos::VirtualNetwork* virt = network_library->virtual_network(); | |
1015 if (!virt) { | |
1016 reply.SendError("Not connected to any virtual network."); | |
1017 return; | |
1018 } | |
1019 | |
1020 network_library->DisconnectFromNetwork(virt); | |
1021 reply.SendSuccess(NULL); | |
1022 } | |
1023 | |
1024 void TestingAutomationProvider::ExecuteJavascriptInOOBEWebUI( | 740 void TestingAutomationProvider::ExecuteJavascriptInOOBEWebUI( |
1025 DictionaryValue* args, IPC::Message* reply_message) { | 741 DictionaryValue* args, IPC::Message* reply_message) { |
1026 std::string javascript, frame_xpath; | 742 std::string javascript, frame_xpath; |
1027 if (!args->GetString("javascript", &javascript)) { | 743 if (!args->GetString("javascript", &javascript)) { |
1028 AutomationJSONReply(this, reply_message) | 744 AutomationJSONReply(this, reply_message) |
1029 .SendError("'javascript' missing or invalid"); | 745 .SendError("'javascript' missing or invalid"); |
1030 return; | 746 return; |
1031 } | 747 } |
1032 if (!args->GetString("frame_xpath", &frame_xpath)) { | 748 if (!args->GetString("frame_xpath", &frame_xpath)) { |
1033 AutomationJSONReply(this, reply_message) | 749 AutomationJSONReply(this, reply_message) |
(...skipping 158 matching lines...) Loading... |
1192 | 908 |
1193 void TestingAutomationProvider::AddChromeosObservers() { | 909 void TestingAutomationProvider::AddChromeosObservers() { |
1194 chromeos::DBusThreadManager::Get()->GetPowerManagerClient()-> | 910 chromeos::DBusThreadManager::Get()->GetPowerManagerClient()-> |
1195 AddObserver(this); | 911 AddObserver(this); |
1196 } | 912 } |
1197 | 913 |
1198 void TestingAutomationProvider::RemoveChromeosObservers() { | 914 void TestingAutomationProvider::RemoveChromeosObservers() { |
1199 chromeos::DBusThreadManager::Get()->GetPowerManagerClient()-> | 915 chromeos::DBusThreadManager::Get()->GetPowerManagerClient()-> |
1200 RemoveObserver(this); | 916 RemoveObserver(this); |
1201 } | 917 } |
OLD | NEW |