diff options
44 files changed, 820 insertions, 459 deletions
diff --git a/chrome/browser/extensions/extension_proxy_api.cc b/chrome/browser/extensions/extension_proxy_api.cc index 9bc33cb..d71c055 100644 --- a/chrome/browser/extensions/extension_proxy_api.cc +++ b/chrome/browser/extensions/extension_proxy_api.cc @@ -7,6 +7,7 @@ #include "base/string_util.h" #include "base/stringprintf.h" #include "base/values.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/extensions/extension_service.h" #include "chrome/common/pref_names.h" @@ -53,8 +54,8 @@ bool UseCustomProxySettingsFunction::RunImpl() { DictionaryValue* proxy_config; EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &proxy_config)); - bool auto_detect = false; - proxy_config->GetBoolean("autoDetect", &auto_detect); + std::string proxy_mode; + proxy_config->GetString("mode", &proxy_mode); DictionaryValue* pac_dict = NULL; proxy_config->GetDictionary("pacScript", &pac_dict); @@ -62,7 +63,9 @@ bool UseCustomProxySettingsFunction::RunImpl() { DictionaryValue* proxy_rules = NULL; proxy_config->GetDictionary("rules", &proxy_rules); - return ApplyAutoDetect(auto_detect) && + // TODO(battre,gfeher): Make sure all the preferences get always + // overwritten. + return ApplyMode(proxy_mode) && ApplyPacScript(pac_dict) && ApplyProxyRules(proxy_rules); } @@ -75,13 +78,19 @@ bool UseCustomProxySettingsFunction::GetProxyServer( return true; } -bool UseCustomProxySettingsFunction::ApplyAutoDetect(bool auto_detect) { - // We take control of the auto-detect preference even if none was specified, - // so that all proxy preferences are controlled by the same extension (if not - // by a higher-priority source). - SendNotification(prefs::kProxyAutoDetect, - Value::CreateBooleanValue(auto_detect)); - return true; +bool UseCustomProxySettingsFunction::ApplyMode(const std::string& mode) { + // We take control of the mode preference even if none was specified, so that + // all proxy preferences are controlled by the same extension (if not by a + // higher-priority source). + bool result = true; + ProxyPrefs::ProxyMode mode_enum; + if (!ProxyPrefs::StringToProxyMode(mode, &mode_enum)) { + mode_enum = ProxyPrefs::MODE_SYSTEM; + LOG(WARNING) << "Invalid mode for proxy settings: " << mode; + result = false; + } + ApplyPreference(prefs::kProxyMode, Value::CreateIntegerValue(mode_enum)); + return result; } bool UseCustomProxySettingsFunction::ApplyPacScript(DictionaryValue* pac_dict) { @@ -92,14 +101,16 @@ bool UseCustomProxySettingsFunction::ApplyPacScript(DictionaryValue* pac_dict) { // We take control of the PAC preference even if none was specified, so that // all proxy preferences are controlled by the same extension (if not by a // higher-priority source). - SendNotification(prefs::kProxyPacUrl, Value::CreateStringValue(pac_url)); + ApplyPreference(prefs::kProxyPacUrl, Value::CreateStringValue(pac_url)); return true; } bool UseCustomProxySettingsFunction::ApplyProxyRules( DictionaryValue* proxy_rules) { - if (!proxy_rules) + if (!proxy_rules) { + ApplyPreference(prefs::kProxyServer, Value::CreateStringValue("")); return true; + } // Local data into which the parameters will be parsed. has_proxy describes // whether a setting was found for the scheme; proxy_dict holds the @@ -153,12 +164,12 @@ bool UseCustomProxySettingsFunction::ApplyProxyRules( } } - SendNotification(prefs::kProxyServer, Value::CreateStringValue(proxy_pref)); + ApplyPreference(prefs::kProxyServer, Value::CreateStringValue(proxy_pref)); return true; } -void UseCustomProxySettingsFunction::SendNotification(const char* pref_path, - Value* pref_value) { +void UseCustomProxySettingsFunction::ApplyPreference(const char* pref_path, + Value* pref_value) { profile()->GetExtensionService()->extension_prefs() ->SetExtensionControlledPref(extension_id(), pref_path, pref_value); } diff --git a/chrome/browser/extensions/extension_proxy_api.h b/chrome/browser/extensions/extension_proxy_api.h index 95be304..d645c44 100644 --- a/chrome/browser/extensions/extension_proxy_api.h +++ b/chrome/browser/extensions/extension_proxy_api.h @@ -33,14 +33,12 @@ class UseCustomProxySettingsFunction : public SyncExtensionFunction { bool GetProxyServer(const DictionaryValue* dict, ProxyServer* proxy_server); - bool ApplyAutoDetect(bool auto_detect); + bool ApplyMode(const std::string& mode); bool ApplyPacScript(DictionaryValue* pac_dict); bool ApplyProxyRules(DictionaryValue* proxy_rules); - // Sends a notification that the given pref would like to change to the - // indicated pref_value. This is mainly useful so the ExtensionPrefStore can - // apply the requested change. - void SendNotification(const char* pref_path, Value* pref_value); + // Takes ownership of |pref_value|. + void ApplyPreference(const char* pref_path, Value* pref_value); }; #endif // CHROME_BROWSER_EXTENSIONS_EXTENSION_PROXY_API_H_ diff --git a/chrome/browser/extensions/extension_proxy_apitest.cc b/chrome/browser/extensions/extension_proxy_apitest.cc index f24b7ef..5537f32 100644 --- a/chrome/browser/extensions/extension_proxy_apitest.cc +++ b/chrome/browser/extensions/extension_proxy_apitest.cc @@ -4,13 +4,46 @@ #include "chrome/browser/extensions/extension_apitest.h" #include "chrome/browser/prefs/pref_service.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/ui/browser.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/extensions/extension.h" #include "chrome/common/pref_names.h" -// Tests auto-detect and PAC proxy settings. +// Tests direct connection settings. +IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyDirectSettings) { + CommandLine::ForCurrentProcess()->AppendSwitch( + switches::kEnableExperimentalExtensionApis); + + ASSERT_TRUE(RunExtensionTest("proxy/direct")) << message_; + const Extension* extension = GetSingleLoadedExtension(); + ASSERT_TRUE(extension); + + PrefService* pref_service = browser()->profile()->GetPrefs(); + + const PrefService::Preference* pref = + pref_service->FindPreference(prefs::kProxyMode); + ASSERT_TRUE(pref != NULL); + ASSERT_TRUE(pref->IsExtensionControlled()); + int mode = pref_service->GetInteger(prefs::kProxyMode); + EXPECT_EQ(ProxyPrefs::MODE_DIRECT, mode); + + // Other proxy prefs should also be set, so they're all controlled from one + // place. + pref = pref_service->FindPreference(prefs::kProxyPacUrl); + ASSERT_TRUE(pref != NULL); + EXPECT_TRUE(pref->IsExtensionControlled()); + EXPECT_EQ("", pref_service->GetString(prefs::kProxyPacUrl)); + + // No manual proxy prefs were set. + pref = pref_service->FindPreference(prefs::kProxyServer); + ASSERT_TRUE(pref != NULL); + EXPECT_TRUE(pref->IsExtensionControlled()); + EXPECT_EQ("", pref_service->GetString(prefs::kProxyServer)); +} + +// Tests auto-detect settings. IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyAutoSettings) { CommandLine::ForCurrentProcess()->AppendSwitch( switches::kEnableExperimentalExtensionApis); @@ -22,11 +55,37 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyAutoSettings) { PrefService* pref_service = browser()->profile()->GetPrefs(); const PrefService::Preference* pref = - pref_service->FindPreference(prefs::kProxyAutoDetect); + pref_service->FindPreference(prefs::kProxyMode); + ASSERT_TRUE(pref != NULL); + ASSERT_TRUE(pref->IsExtensionControlled()); + int mode = pref_service->GetInteger(prefs::kProxyMode); + EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, mode); + + // Other proxy prefs should also be set, so they're all controlled from one + // place. + pref = pref_service->FindPreference(prefs::kProxyPacUrl); + ASSERT_TRUE(pref != NULL); + EXPECT_TRUE(pref->IsExtensionControlled()); + EXPECT_EQ("", pref_service->GetString(prefs::kProxyPacUrl)); +} + +// Tests PAC proxy settings. +IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyPacScript) { + CommandLine::ForCurrentProcess()->AppendSwitch( + switches::kEnableExperimentalExtensionApis); + + ASSERT_TRUE(RunExtensionTest("proxy/pac")) << message_; + const Extension* extension = GetSingleLoadedExtension(); + ASSERT_TRUE(extension); + + PrefService* pref_service = browser()->profile()->GetPrefs(); + + const PrefService::Preference* pref = + pref_service->FindPreference(prefs::kProxyMode); ASSERT_TRUE(pref != NULL); ASSERT_TRUE(pref->IsExtensionControlled()); - bool auto_detect = pref_service->GetBoolean(prefs::kProxyAutoDetect); - EXPECT_TRUE(auto_detect); + int mode = pref_service->GetInteger(prefs::kProxyMode); + EXPECT_EQ(ProxyPrefs::MODE_PAC_SCRIPT, mode); pref = pref_service->FindPreference(prefs::kProxyPacUrl); ASSERT_TRUE(pref != NULL); @@ -37,11 +96,12 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyAutoSettings) { // No manual proxy prefs were set. pref = pref_service->FindPreference(prefs::kProxyServer); ASSERT_TRUE(pref != NULL); - EXPECT_TRUE(pref->IsDefaultValue()); + EXPECT_TRUE(pref->IsExtensionControlled()); + EXPECT_EQ("", pref_service->GetString(prefs::kProxyServer)); } // Tests setting a single proxy to cover all schemes. -IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyManualSingle) { +IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyFixedSingle) { CommandLine::ForCurrentProcess()->AppendSwitch( switches::kEnableExperimentalExtensionApis); @@ -64,19 +124,53 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyManualSingle) { // Other proxy prefs should also be set, so they're all controlled from one // place. - pref = pref_service->FindPreference(prefs::kProxyAutoDetect); + pref = pref_service->FindPreference(prefs::kProxyMode); + ASSERT_TRUE(pref != NULL); + EXPECT_TRUE(pref->IsExtensionControlled()); + EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, + pref_service->GetInteger(prefs::kProxyMode)); + + pref = pref_service->FindPreference(prefs::kProxyPacUrl); ASSERT_TRUE(pref != NULL); EXPECT_TRUE(pref->IsExtensionControlled()); - EXPECT_FALSE(pref_service->GetBoolean(prefs::kProxyAutoDetect)); + EXPECT_EQ("", pref_service->GetString(prefs::kProxyPacUrl)); +} + +// Tests setting to use the system's proxy settings. +IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxySystem) { + CommandLine::ForCurrentProcess()->AppendSwitch( + switches::kEnableExperimentalExtensionApis); + + ASSERT_TRUE(RunExtensionTest("proxy/system")) << message_; + const Extension* extension = GetSingleLoadedExtension(); + ASSERT_TRUE(extension); + + PrefService* pref_service = browser()->profile()->GetPrefs(); + + // There should be no values superseding the extension-set proxy in this test. + const PrefService::Preference* pref = + pref_service->FindPreference(prefs::kProxyMode); + ASSERT_TRUE(pref != NULL); + ASSERT_TRUE(pref->IsExtensionControlled()); + int proxy_server_mode = pref_service->GetInteger(prefs::kProxyMode); + EXPECT_EQ(ProxyPrefs::MODE_SYSTEM, proxy_server_mode); + // Other proxy prefs should also be set, so they're all controlled from one + // place. pref = pref_service->FindPreference(prefs::kProxyPacUrl); ASSERT_TRUE(pref != NULL); EXPECT_TRUE(pref->IsExtensionControlled()); EXPECT_EQ("", pref_service->GetString(prefs::kProxyPacUrl)); + + // No manual proxy prefs were set. + pref = pref_service->FindPreference(prefs::kProxyServer); + ASSERT_TRUE(pref != NULL); + EXPECT_TRUE(pref->IsExtensionControlled()); + EXPECT_EQ("", pref_service->GetString(prefs::kProxyServer)); } // Tests setting separate proxies for each scheme. -IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyManualIndividual) { +IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyFixedIndividual) { CommandLine::ForCurrentProcess()->AppendSwitch( switches::kEnableExperimentalExtensionApis); @@ -100,10 +194,11 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ProxyManualIndividual) { // Other proxy prefs should also be set, so they're all controlled from one // place. - pref = pref_service->FindPreference(prefs::kProxyAutoDetect); + pref = pref_service->FindPreference(prefs::kProxyMode); ASSERT_TRUE(pref != NULL); EXPECT_TRUE(pref->IsExtensionControlled()); - EXPECT_FALSE(pref_service->GetBoolean(prefs::kProxyAutoDetect)); + EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, + pref_service->GetInteger(prefs::kProxyMode)); pref = pref_service->FindPreference(prefs::kProxyPacUrl); ASSERT_TRUE(pref != NULL); diff --git a/chrome/browser/net/pref_proxy_config_service.cc b/chrome/browser/net/pref_proxy_config_service.cc index 10ae74b..2b10104 100644 --- a/chrome/browser/net/pref_proxy_config_service.cc +++ b/chrome/browser/net/pref_proxy_config_service.cc @@ -8,38 +8,12 @@ #include "chrome/browser/browser_thread.h" #include "chrome/browser/prefs/pref_service.h" #include "chrome/browser/prefs/pref_set_observer.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/common/notification_details.h" #include "chrome/common/notification_source.h" #include "chrome/common/notification_type.h" #include "chrome/common/pref_names.h" -namespace { - -const bool kProxyPrefDefaultBoolean = false; -const char kProxyPrefDefaultString[] = ""; - -// Determines if a value of a proxy pref is set to its default. Default values -// have a special role in the proxy pref system, because if all of the proxy -// prefs are set to their defaults, then the system proxy settings are applied. -// TODO(gfeher): Proxy preferences should be refactored to avoid the need -// for such solutions. See crbug.com/65732 -bool IsDefaultValue(const Value* value) { - bool b = false; - std::string s; - if (value->IsType(Value::TYPE_BOOLEAN) && - value->GetAsBoolean(&b)) { - return b == kProxyPrefDefaultBoolean; - } else if (value->IsType(Value::TYPE_STRING) && - value->GetAsString(&s)) { - return s == kProxyPrefDefaultString; - } else { - NOTREACHED() << "Invalid type for a proxy preference."; - return false; - } -} - -} // namespace - PrefProxyConfigTracker::PrefProxyConfigTracker(PrefService* pref_service) : pref_service_(pref_service) { valid_ = ReadPrefConfig(&pref_config_); @@ -112,65 +86,62 @@ bool PrefProxyConfigTracker::ReadPrefConfig(net::ProxyConfig* config) { // Clear the configuration. *config = net::ProxyConfig(); - // Scan for all "enable" type proxy switches. - static const char* proxy_prefs[] = { - prefs::kProxyPacUrl, - prefs::kProxyServer, - prefs::kProxyBypassList, - prefs::kProxyAutoDetect - }; - - // Check whether the preference system holds a valid proxy configuration. Note - // that preferences coming from a lower-priority source than the user settings - // are ignored. That's because chrome treats the system settings as the - // default values, which should apply if there's no explicit value forced by - // policy or the user. - // Preferences that are set to their default values are also ignored, - // regardless of their controlling source. This is because 'use system proxy - // settings' is currently encoded by all the preferences being set to their - // defaults. This will change when crbug.com/65732 is addressed. - bool found_enable_proxy_pref = false; - for (size_t i = 0; i < arraysize(proxy_prefs); i++) { - const PrefService::Preference* pref = - pref_service_->FindPreference(proxy_prefs[i]); - DCHECK(pref); - if (pref && (!pref->IsUserModifiable() || pref->HasUserSetting()) && - !IsDefaultValue(pref->GetValue())) { - found_enable_proxy_pref = true; - break; - } - } - - if (!found_enable_proxy_pref && - !pref_service_->GetBoolean(prefs::kNoProxyServer)) { + ProxyPrefs::ProxyMode mode; + int proxy_mode = pref_service_->GetInteger(prefs::kProxyMode); + if (!ProxyPrefs::IntToProxyMode(proxy_mode, &mode)) { + // Fall back to system settings if the mode preference is invalid. return false; } - if (pref_service_->GetBoolean(prefs::kNoProxyServer)) { - // Ignore all the other proxy config preferences if the use of a proxy - // has been explicitly disabled. - return true; - } - - if (pref_service_->HasPrefPath(prefs::kProxyServer)) { - std::string proxy_server = pref_service_->GetString(prefs::kProxyServer); - config->proxy_rules().ParseFromString(proxy_server); - } - - if (pref_service_->HasPrefPath(prefs::kProxyPacUrl)) { - std::string proxy_pac = pref_service_->GetString(prefs::kProxyPacUrl); - config->set_pac_url(GURL(proxy_pac)); - } - - config->set_auto_detect(pref_service_->GetBoolean(prefs::kProxyAutoDetect)); - - if (pref_service_->HasPrefPath(prefs::kProxyBypassList)) { - std::string proxy_bypass = - pref_service_->GetString(prefs::kProxyBypassList); - config->proxy_rules().bypass_rules.ParseFromString(proxy_bypass); + switch (mode) { + case ProxyPrefs::MODE_SYSTEM: + // Use system settings. + return false; + case ProxyPrefs::MODE_DIRECT: + // Ignore all the other proxy config preferences if the use of a proxy + // has been explicitly disabled. + return true; + case ProxyPrefs::MODE_AUTO_DETECT: + config->set_auto_detect(true); + return true; + case ProxyPrefs::MODE_PAC_SCRIPT: { + if (!pref_service_->HasPrefPath(prefs::kProxyPacUrl)) { + LOG(ERROR) << "Proxy settings request PAC script but do not specify " + << "its URL. Falling back to direct connection."; + return true; + } + std::string proxy_pac = pref_service_->GetString(prefs::kProxyPacUrl); + GURL proxy_pac_url(proxy_pac); + if (!proxy_pac_url.is_valid()) { + LOG(ERROR) << "Invalid proxy PAC url: " << proxy_pac; + return true; + } + config->set_pac_url(proxy_pac_url); + return true; + } + case ProxyPrefs::MODE_FIXED_SERVERS: { + if (!pref_service_->HasPrefPath(prefs::kProxyServer)) { + LOG(ERROR) << "Proxy settings request fixed proxy servers but do not " + << "specify their URLs. Falling back to direct connection."; + return true; + } + std::string proxy_server = + pref_service_->GetString(prefs::kProxyServer); + config->proxy_rules().ParseFromString(proxy_server); + + if (pref_service_->HasPrefPath(prefs::kProxyBypassList)) { + std::string proxy_bypass = + pref_service_->GetString(prefs::kProxyBypassList); + config->proxy_rules().bypass_rules.ParseFromString(proxy_bypass); + } + return true; + } + case ProxyPrefs::kModeCount: { + // Fall through to NOTREACHED(). + } } - - return true; + NOTREACHED() << "Unknown proxy mode, falling back to system settings."; + return false; } PrefProxyConfigService::PrefProxyConfigService( @@ -258,14 +229,8 @@ void PrefProxyConfigService::RegisterObservers() { // static void PrefProxyConfigService::RegisterUserPrefs( PrefService* pref_service) { - pref_service->RegisterBooleanPref(prefs::kNoProxyServer, - kProxyPrefDefaultBoolean); - pref_service->RegisterBooleanPref(prefs::kProxyAutoDetect, - kProxyPrefDefaultBoolean); - pref_service->RegisterStringPref(prefs::kProxyServer, - kProxyPrefDefaultString); - pref_service->RegisterStringPref(prefs::kProxyPacUrl, - kProxyPrefDefaultString); - pref_service->RegisterStringPref(prefs::kProxyBypassList, - kProxyPrefDefaultString); + pref_service->RegisterIntegerPref(prefs::kProxyMode, ProxyPrefs::MODE_SYSTEM); + pref_service->RegisterStringPref(prefs::kProxyServer, ""); + pref_service->RegisterStringPref(prefs::kProxyPacUrl, ""); + pref_service->RegisterStringPref(prefs::kProxyBypassList, ""); } diff --git a/chrome/browser/net/pref_proxy_config_service_unittest.cc b/chrome/browser/net/pref_proxy_config_service_unittest.cc index cc602ec..dad5c53 100644 --- a/chrome/browser/net/pref_proxy_config_service_unittest.cc +++ b/chrome/browser/net/pref_proxy_config_service_unittest.cc @@ -8,6 +8,7 @@ #include "base/file_path.h" #include "chrome/browser/net/chrome_url_request_context.h" #include "chrome/browser/prefs/pref_service_mock_builder.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/pref_names.h" #include "chrome/test/testing_pref_service.h" @@ -114,6 +115,9 @@ TEST_F(PrefProxyConfigServiceTest, BaseConfiguration) { TEST_F(PrefProxyConfigServiceTest, DynamicPrefOverrides) { pref_service_->SetManagedPref( prefs::kProxyServer, Value::CreateStringValue("http://example.com:3128")); + pref_service_->SetManagedPref( + prefs::kProxyMode, + Value::CreateIntegerValue(ProxyPrefs::MODE_FIXED_SERVERS)); loop_.RunAllPending(); net::ProxyConfig actual_config; @@ -126,7 +130,8 @@ TEST_F(PrefProxyConfigServiceTest, DynamicPrefOverrides) { net::ProxyServer::SCHEME_HTTP)); pref_service_->SetManagedPref( - prefs::kProxyAutoDetect, Value::CreateBooleanValue(true)); + prefs::kProxyMode, + Value::CreateIntegerValue(ProxyPrefs::MODE_AUTO_DETECT)); loop_.RunAllPending(); proxy_config_service_->GetLatestProxyConfig(&actual_config); @@ -156,10 +161,20 @@ TEST_F(PrefProxyConfigServiceTest, Observers) { // Override configuration, this should trigger a notification. net::ProxyConfig pref_config; pref_config.set_pac_url(GURL(kFixedPacUrl)); + EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(pref_config))).Times(1); + pref_service_->SetManagedPref(prefs::kProxyPacUrl, Value::CreateStringValue(kFixedPacUrl)); + // The above does not trigger a notification, because PrefProxyConfig still + // sees the mode as the default (ProxyPrefs::SYSTEM), so that it doesn't claim + // to have proxy config. + // TODO(battre): Remove this comment when http://crbug.com/65732 is + // resolved. + pref_service_->SetManagedPref( + prefs::kProxyMode, + Value::CreateIntegerValue(ProxyPrefs::MODE_PAC_SCRIPT)); loop_.RunAllPending(); Mock::VerifyAndClearExpectations(&observer); @@ -175,6 +190,11 @@ TEST_F(PrefProxyConfigServiceTest, Observers) { // Clear the override should switch back to the fixed configuration. EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config3))).Times(1); + pref_service_->RemoveManagedPref(prefs::kProxyMode); + // The above switches the mode to the default (ProxyPrefs::SYSTEM), so the + // next removal won't bother PrefProxyConfigService. + // TODO(battre): Remove this comment when http://crbug.com/65732 is + // completed. pref_service_->RemoveManagedPref(prefs::kProxyPacUrl); loop_.RunAllPending(); Mock::VerifyAndClearExpectations(&observer); @@ -350,19 +370,16 @@ static const CommandLineTestParams kCommandLineTestParams[] = { "*.google.com,foo.com:99,1.2.3.4:22,127.0.0.1/8"), }, { - "Pac URL with proxy bypass URLs", + "Pac URL", // Input { { switches::kProxyPacUrl, "http://wpad/wpad.dat" }, - { switches::kProxyBypassList, - ".google.com, foo.com:99, 1.2.3.4:22, 127.0.0.1/8" }, }, // Expected result false, // is_null false, // auto_detect GURL("http://wpad/wpad.dat"), // pac_url - net::ProxyRulesExpectation::EmptyWithBypass( - "*.google.com,foo.com:99,1.2.3.4:22,127.0.0.1/8"), + net::ProxyRulesExpectation::Empty(), }, { "Autodetect", diff --git a/chrome/browser/policy/config_dir_policy_provider_unittest.cc b/chrome/browser/policy/config_dir_policy_provider_unittest.cc index 7197f490..8b7e9a0 100644 --- a/chrome/browser/policy/config_dir_policy_provider_unittest.cc +++ b/chrome/browser/policy/config_dir_policy_provider_unittest.cc @@ -259,8 +259,8 @@ INSTANTIATE_TEST_CASE_P( kPolicyDefaultSearchProviderEncodings, key::kDefaultSearchProviderEncodings), ValueTestParams::ForIntegerPolicy( - kPolicyProxyServerMode, - key::kProxyServerMode), + kPolicyProxyMode, + key::kProxyMode), ValueTestParams::ForStringPolicy( kPolicyProxyServer, key::kProxyServer), diff --git a/chrome/browser/policy/configuration_policy_pref_store.cc b/chrome/browser/policy/configuration_policy_pref_store.cc index 3971980..3c7ea6a 100644 --- a/chrome/browser/policy/configuration_policy_pref_store.cc +++ b/chrome/browser/policy/configuration_policy_pref_store.cc @@ -8,10 +8,12 @@ #include "base/lazy_instance.h" #include "base/logging.h" #include "base/path_service.h" +#include "base/stl_util-inl.h" #include "base/string16.h" #include "base/string_util.h" #include "base/utf_string_conversions.h" #include "base/values.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/policy/configuration_policy_provider.h" #if defined(OS_WIN) @@ -248,7 +250,7 @@ ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList() { key::kDefaultSearchProviderIconURL }, { kPolicyDefaultSearchProviderEncodings, Value::TYPE_STRING, key::kDefaultSearchProviderEncodings }, - { kPolicyProxyServerMode, Value::TYPE_INTEGER, key::kProxyServerMode }, + { kPolicyProxyMode, Value::TYPE_INTEGER, key::kProxyMode }, { kPolicyProxyServer, Value::TYPE_STRING, key::kProxyServer }, { kPolicyProxyPacUrl, Value::TYPE_STRING, key::kProxyPacUrl }, { kPolicyProxyBypassList, Value::TYPE_STRING, key::kProxyBypassList }, @@ -331,17 +333,16 @@ ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList() { ConfigurationPolicyPrefStore::ConfigurationPolicyPrefStore( ConfigurationPolicyProvider* provider) : provider_(provider), - prefs_(new DictionaryValue()), - lower_priority_proxy_settings_overridden_(false), - proxy_disabled_(false), - proxy_configuration_specified_(false), - use_system_proxy_(false) { + prefs_(new DictionaryValue()) { if (!provider_->Provide(this)) LOG(WARNING) << "Failed to get policy from provider."; + FinalizeProxyPolicySettings(); FinalizeDefaultSearchPolicySettings(); } -ConfigurationPolicyPrefStore::~ConfigurationPolicyPrefStore() {} +ConfigurationPolicyPrefStore::~ConfigurationPolicyPrefStore() { + DCHECK(proxy_policies_.empty()); +} PrefStore::ReadResult ConfigurationPolicyPrefStore::GetValue( const std::string& key, @@ -415,17 +416,6 @@ ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore() { g_configuration_policy_provider_keeper.Get().recommended_provider()); } -// static -void ConfigurationPolicyPrefStore::GetProxyPreferenceSet( - ProxyPreferenceSet* proxy_pref_set) { - proxy_pref_set->clear(); - for (size_t current = 0; current < arraysize(kProxyPolicyMap); ++current) { - proxy_pref_set->insert(kProxyPolicyMap[current].preference_path); - } - proxy_pref_set->insert(prefs::kNoProxyServer); - proxy_pref_set->insert(prefs::kProxyAutoDetect); -} - const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry* ConfigurationPolicyPrefStore::FindPolicyInMap( ConfigurationPolicyType policy, @@ -469,108 +459,152 @@ bool ConfigurationPolicyPrefStore::ApplyPolicyFromMap( bool ConfigurationPolicyPrefStore::ApplyProxyPolicy( ConfigurationPolicyType policy, Value* value) { - bool result = false; - bool warn_about_proxy_disable_config = false; - bool warn_about_proxy_system_config = false; - - const PolicyToPreferenceMapEntry* match_entry = - FindPolicyInMap(policy, kProxyPolicyMap, arraysize(kProxyPolicyMap)); - - // When the first proxy-related policy is applied, ALL proxy-related - // preferences that have been set by command-line switches, extensions, - // user preferences or any other mechanism are overridden. Otherwise - // it's possible for a user to interfere with proxy policy by setting - // proxy-related command-line switches or set proxy-related prefs in an - // extension that are related, but not identical, to the ones set through - // policy. - if (!lower_priority_proxy_settings_overridden_ && - (match_entry || - policy == kPolicyProxyServerMode)) { - ProxyPreferenceSet proxy_preference_set; - GetProxyPreferenceSet(&proxy_preference_set); - for (ProxyPreferenceSet::const_iterator i = proxy_preference_set.begin(); - i != proxy_preference_set.end(); ++i) { - // We use values of TYPE_NULL to mark preferences for which - // READ_USE_DEFAULT should be returned by GetValue(). - prefs_->Set(*i, Value::CreateNullValue()); - } - lower_priority_proxy_settings_overridden_ = true; + // We only collect the values until we have sufficient information when + // FinalizeProxyPolicySettings() is called to determine whether the presented + // values were correct and apply them in that case. + if (policy == kPolicyProxyMode || + policy == kPolicyProxyServer || + policy == kPolicyProxyPacUrl || + policy == kPolicyProxyBypassList) { + delete proxy_policies_[policy]; + proxy_policies_[policy] = value; + return true; } + // We are not interested in this policy. + return false; +} - // Translate the proxy policy into preferences. - if (policy == kPolicyProxyServerMode) { - int int_value; - bool proxy_auto_detect = false; - if (value->GetAsInteger(&int_value)) { - result = true; - switch (int_value) { - case kPolicyNoProxyServerMode: - if (!proxy_disabled_) { - if (proxy_configuration_specified_) - warn_about_proxy_disable_config = true; - proxy_disabled_ = true; - } - break; - case kPolicyAutoDetectProxyMode: - proxy_auto_detect = true; - break; - case kPolicyManuallyConfiguredProxyMode: - break; - case kPolicyUseSystemProxyMode: - if (!use_system_proxy_) { - if (proxy_configuration_specified_) - warn_about_proxy_system_config = true; - use_system_proxy_ = true; - } - break; - default: - // Not a valid policy, don't assume ownership of |value| - result = false; - break; - } +void ConfigurationPolicyPrefStore::FinalizeProxyPolicySettings() { + if (CheckProxySettings()) + ApplyProxySettings(); - if (int_value != kPolicyUseSystemProxyMode) { - prefs_->Set(prefs::kNoProxyServer, - Value::CreateBooleanValue(proxy_disabled_)); - prefs_->Set(prefs::kProxyAutoDetect, - Value::CreateBooleanValue(proxy_auto_detect)); - } - } - } else if (match_entry) { - // Determine if the applied proxy policy settings conflict and issue - // a corresponding warning if they do. - if (!proxy_configuration_specified_) { - if (proxy_disabled_) - warn_about_proxy_disable_config = true; - if (use_system_proxy_) - warn_about_proxy_system_config = true; - proxy_configuration_specified_ = true; - } - if (!use_system_proxy_ && !proxy_disabled_) { - prefs_->Set(match_entry->preference_path, value); - // The ownership of value has been passed on to |prefs_|, - // don't clean it up later. - value = NULL; - } - result = true; + STLDeleteContainerPairSecondPointers(proxy_policies_.begin(), + proxy_policies_.end()); + proxy_policies_.clear(); +} + +bool ConfigurationPolicyPrefStore::HasProxyPolicy( + ConfigurationPolicyType policy) const { + std::map<ConfigurationPolicyType, Value*>::const_iterator iter; + iter = proxy_policies_.find(policy); + return iter != proxy_policies_.end() && + iter->second && !iter->second->IsType(Value::TYPE_NULL); +} + +bool ConfigurationPolicyPrefStore::CheckProxySettings() { + bool mode = HasProxyPolicy(kPolicyProxyMode); + bool server = HasProxyPolicy(kPolicyProxyServer); + bool pac_url = HasProxyPolicy(kPolicyProxyPacUrl); + bool bypass_list = HasProxyPolicy(kPolicyProxyBypassList); + + if ((server || pac_url || bypass_list) && !mode) { + LOG(WARNING) << "A centrally-administered policy defines proxy setting" + << " details without setting a proxy mode."; + return false; } - if (warn_about_proxy_disable_config) { - LOG(WARNING) << "A centrally-administered policy disables the use of" - << " a proxy but also specifies an explicit proxy" - << " configuration."; + if (!mode) + return true; + + int mode_value; + if (!proxy_policies_[kPolicyProxyMode]->GetAsInteger(&mode_value)) { + LOG(WARNING) << "Invalid proxy mode value."; + return false; } - if (warn_about_proxy_system_config) { - LOG(WARNING) << "A centrally-administered policy dictates that the" - << " system proxy settings should be used but also specifies" - << " an explicit proxy configuration."; + switch (mode_value) { + case kPolicyNoProxyServerMode: + if (server || pac_url || bypass_list) { + LOG(WARNING) << "A centrally-administered policy disables the use of" + << " a proxy but also specifies an explicit proxy" + << " configuration."; + return false; + } + break; + case kPolicyAutoDetectProxyMode: + if (server || bypass_list) { + LOG(WARNING) << "A centrally-administered policy dictates that a proxy" + << " shall be auto configured but specifies fixed proxy" + << " servers or a by-pass list."; + return false; + } + break; + case kPolicyManuallyConfiguredProxyMode: + if (!server) { + LOG(WARNING) << "A centrally-administered policy dictates that the" + << " system proxy settings should use fixed proxy servers" + << " without specifying which ones."; + return false; + } + if (pac_url) { + LOG(WARNING) << "A centrally-administered policy dictates that the" + << " system proxy settings should use fixed proxy servers" + << " but also specifies a PAC script."; + return false; + } + break; + case kPolicyUseSystemProxyMode: + if (server || pac_url || bypass_list) { + LOG(WARNING) << "A centrally-administered policy dictates that the" + << " system proxy settings should be used but also " + << " specifies an explicit proxy configuration."; + return false; + } + break; + default: + LOG(WARNING) << "Invalid proxy mode " << mode_value; + return false; } + return true; +} - // If the policy was a proxy policy, cleanup |value|. - if (result && value) - delete value; - return result; +void ConfigurationPolicyPrefStore::ApplyProxySettings() { + if (!HasProxyPolicy(kPolicyProxyMode)) + return; + + int int_mode; + CHECK(proxy_policies_[kPolicyProxyMode]->GetAsInteger(&int_mode)); + ProxyPrefs::ProxyMode mode; + switch (int_mode) { + case kPolicyNoProxyServerMode: + mode = ProxyPrefs::MODE_DIRECT; + break; + case kPolicyAutoDetectProxyMode: + mode = ProxyPrefs::MODE_AUTO_DETECT; + if (HasProxyPolicy(kPolicyProxyPacUrl)) + mode = ProxyPrefs::MODE_PAC_SCRIPT; + break; + case kPolicyManuallyConfiguredProxyMode: + mode = ProxyPrefs::MODE_FIXED_SERVERS; + break; + case kPolicyUseSystemProxyMode: + mode = ProxyPrefs::MODE_SYSTEM; + break; + default: + mode = ProxyPrefs::MODE_DIRECT; + NOTREACHED(); + } + prefs_->Set(prefs::kProxyMode, Value::CreateIntegerValue(mode)); + + if (HasProxyPolicy(kPolicyProxyServer)) { + prefs_->Set(prefs::kProxyServer, proxy_policies_[kPolicyProxyServer]); + proxy_policies_[kPolicyProxyServer] = NULL; + } else { + prefs_->Set(prefs::kProxyServer, Value::CreateNullValue()); + } + if (HasProxyPolicy(kPolicyProxyPacUrl)) { + prefs_->Set(prefs::kProxyPacUrl, proxy_policies_[kPolicyProxyPacUrl]); + proxy_policies_[kPolicyProxyPacUrl] = NULL; + } else { + prefs_->Set(prefs::kProxyPacUrl, Value::CreateNullValue()); + } + if (HasProxyPolicy(kPolicyProxyBypassList)) { + prefs_->Set(prefs::kProxyBypassList, + proxy_policies_[kPolicyProxyBypassList]); + proxy_policies_[kPolicyProxyBypassList] = NULL; + } else { + prefs_->Set(prefs::kProxyBypassList, Value::CreateNullValue()); + } } bool ConfigurationPolicyPrefStore::ApplySyncPolicy( diff --git a/chrome/browser/policy/configuration_policy_pref_store.h b/chrome/browser/policy/configuration_policy_pref_store.h index 820306a..6d0ae15 100644 --- a/chrome/browser/policy/configuration_policy_pref_store.h +++ b/chrome/browser/policy/configuration_policy_pref_store.h @@ -56,10 +56,6 @@ class ConfigurationPolicyPrefStore : public PrefStore, static const ConfigurationPolicyProvider::PolicyDefinitionList* GetChromePolicyDefinitionList(); - // Returns the set of preference paths that can be affected by a proxy - // policy. - static void GetProxyPreferenceSet(ProxyPreferenceSet* proxy_pref_set); - private: // Policies that map to a single preference are handled // by an automated converter. Each one of these policies @@ -79,23 +75,11 @@ class ConfigurationPolicyPrefStore : public PrefStore, ConfigurationPolicyProvider* provider_; scoped_ptr<DictionaryValue> prefs_; - // Set to false until the first proxy-relevant policy is applied. At that - // time, default values are provided for all proxy-relevant prefs - // to override any values set from stores with a lower priority. - bool lower_priority_proxy_settings_overridden_; - - // The following are used to track what proxy-relevant policy has been applied - // accross calls to Apply to provide a warning if a policy specifies a - // contradictory proxy configuration. |proxy_disabled_| is set to true if and - // only if the kPolicyNoProxyServer has been applied, - // |proxy_configuration_specified_| is set to true if and only if any other - // proxy policy other than kPolicyNoProxyServer has been applied. - bool proxy_disabled_; - bool proxy_configuration_specified_; + // Temporary cache that stores values until FinalizeProxyPolicySettings() + // is called. + std::map<ConfigurationPolicyType, Value*> proxy_policies_; - // Set to true if a the proxy mode policy has been set to force Chrome - // to use the system proxy. - bool use_system_proxy_; + bool HasProxyPolicy(ConfigurationPolicyType policy) const; // Returns the map entry that corresponds to |policy| in the map. const PolicyToPreferenceMapEntry* FindPolicyInMap( @@ -136,6 +120,19 @@ class ConfigurationPolicyPrefStore : public PrefStore, // map entries from |prefs_|. void FinalizeDefaultSearchPolicySettings(); + // If the required entries for the proxy settings are specified and valid, + // finalizes the policy-specified configuration by initializing the + // respective values in |prefs_|. + void FinalizeProxyPolicySettings(); + + // Returns true if the policy values stored in proxy_* represent a valid + // proxy configuration. + bool CheckProxySettings(); + + // Assumes CheckProxySettings returns true and applies the values stored + // in proxy_*. + void ApplyProxySettings(); + DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyPrefStore); }; diff --git a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc index 43e1295..5dad5dc 100644 --- a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc +++ b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc @@ -7,6 +7,7 @@ #include "base/file_path.h" #include "chrome/browser/policy/configuration_policy_pref_store.h" #include "chrome/browser/policy/mock_configuration_policy_provider.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/common/pref_names.h" #include "chrome/common/chrome_switches.h" @@ -96,7 +97,7 @@ TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) { TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) { store_.Apply(GetParam().type(), - Value::CreateStringValue("http://chromium.org")); + Value::CreateStringValue("http://chromium.org")); std::string result; EXPECT_TRUE(store_.prefs()->GetString(GetParam().pref_name(), &result)); EXPECT_EQ(result, "http://chromium.org"); @@ -108,12 +109,6 @@ INSTANTIATE_TEST_CASE_P( testing::Values( TypeAndName(kPolicyHomePage, prefs::kHomePage), - TypeAndName(kPolicyProxyServer, - prefs::kProxyServer), - TypeAndName(kPolicyProxyPacUrl, - prefs::kProxyPacUrl), - TypeAndName(kPolicyProxyBypassList, - prefs::kProxyBypassList), TypeAndName(kPolicyApplicationLocale, prefs::kApplicationLocale), TypeAndName(kPolicyApplicationLocale, @@ -225,6 +220,44 @@ INSTANTIATE_TEST_CASE_P( // Test cases for the proxy policy settings. class ConfigurationPolicyPrefStoreProxyTest : public testing::Test { + protected: + // Verify that all the proxy prefs are set to the specified expected values. + static void VerifyProxyPrefs( + const ConfigurationPolicyPrefStore& store, + const std::string& expected_proxy_server, + const std::string& expected_proxy_pac_url, + const std::string& expected_proxy_bypass_list, + const ProxyPrefs::ProxyMode& expected_proxy_mode) { + std::string string_result; + + if (expected_proxy_server.empty()) { + EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, + &string_result)); + } else { + EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyServer, + &string_result)); + EXPECT_EQ(expected_proxy_server, string_result); + } + if (expected_proxy_pac_url.empty()) { + EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, + &string_result)); + } else { + EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl, + &string_result)); + EXPECT_EQ(expected_proxy_pac_url, string_result); + } + if (expected_proxy_bypass_list.empty()) { + EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList, + &string_result)); + } else { + EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyBypassList, + &string_result)); + EXPECT_EQ(expected_proxy_bypass_list, string_result); + } + int int_result = -1; + EXPECT_TRUE(store.prefs()->GetInteger(prefs::kProxyMode, &int_result)); + EXPECT_EQ(expected_proxy_mode, int_result); + } }; TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) { @@ -232,140 +265,95 @@ TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) { new MockConfigurationPolicyProvider()); provider->AddPolicy(kPolicyProxyBypassList, Value::CreateStringValue("http://chromium.org/override")); - provider->AddPolicy(kPolicyProxyPacUrl, - Value::CreateStringValue("http://short.org/proxy.pac")); provider->AddPolicy(kPolicyProxyServer, Value::CreateStringValue("chromium.org")); - provider->AddPolicy(kPolicyProxyServerMode, + provider->AddPolicy(kPolicyProxyMode, Value::CreateIntegerValue( kPolicyManuallyConfiguredProxyMode)); ConfigurationPolicyPrefStore store(provider.get()); - - std::string string_result; - EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyBypassList, - &string_result)); - EXPECT_EQ("http://chromium.org/override", string_result); - EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result)); - EXPECT_EQ("http://short.org/proxy.pac", string_result); - EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyServer, &string_result)); - EXPECT_EQ("chromium.org", string_result); - bool bool_result; - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result)); - EXPECT_FALSE(bool_result); - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result)); - EXPECT_FALSE(bool_result); + VerifyProxyPrefs( + store, "chromium.org", "", "http://chromium.org/override", + ProxyPrefs::MODE_FIXED_SERVERS); } -TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) { +TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) { scoped_ptr<MockConfigurationPolicyProvider> provider( new MockConfigurationPolicyProvider()); + provider->AddPolicy(kPolicyProxyMode, + Value::CreateIntegerValue( + kPolicyManuallyConfiguredProxyMode)); provider->AddPolicy(kPolicyProxyBypassList, Value::CreateStringValue("http://chromium.org/override")); - provider->AddPolicy(kPolicyProxyServerMode, - Value::CreateIntegerValue( - kPolicyNoProxyServerMode)); + provider->AddPolicy(kPolicyProxyServer, + Value::CreateStringValue("chromium.org")); ConfigurationPolicyPrefStore store(provider.get()); - - std::string string_result; - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList, - &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result)); - bool bool_result; - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result)); - EXPECT_TRUE(bool_result); - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result)); - EXPECT_FALSE(bool_result); + VerifyProxyPrefs( + store, "chromium.org", "", "http://chromium.org/override", + ProxyPrefs::MODE_FIXED_SERVERS); } -TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyReversedApplyOrder) { +TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) { scoped_ptr<MockConfigurationPolicyProvider> provider( new MockConfigurationPolicyProvider()); - provider->AddPolicy(kPolicyProxyServerMode, - Value::CreateIntegerValue( - kPolicyNoProxyServerMode)); - provider->AddPolicy(kPolicyProxyBypassList, - Value::CreateStringValue("http://chromium.org/override")); + provider->AddPolicy(kPolicyProxyMode, + Value::CreateIntegerValue(kPolicyNoProxyServerMode)); ConfigurationPolicyPrefStore store(provider.get()); - - std::string string_result; - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList, - &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result)); - bool bool_result; - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result)); - EXPECT_TRUE(bool_result); - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result)); - EXPECT_FALSE(bool_result); + VerifyProxyPrefs(store, "", "", "", ProxyPrefs::MODE_DIRECT); } TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) { scoped_ptr<MockConfigurationPolicyProvider> provider( new MockConfigurationPolicyProvider()); - provider->AddPolicy(kPolicyProxyServerMode, - Value::CreateIntegerValue( - kPolicyAutoDetectProxyMode)); + provider->AddPolicy(kPolicyProxyMode, + Value::CreateIntegerValue(kPolicyAutoDetectProxyMode)); ConfigurationPolicyPrefStore store(provider.get()); - - std::string string_result; - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList, - &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result)); - bool bool_result; - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result)); - EXPECT_FALSE(bool_result); - EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result)); - EXPECT_TRUE(bool_result); + VerifyProxyPrefs(store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT); } -TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) { +TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectPac) { scoped_ptr<MockConfigurationPolicyProvider> provider( new MockConfigurationPolicyProvider()); - provider->AddPolicy(kPolicyProxyBypassList, - Value::CreateStringValue("http://chromium.org/override")); - provider->AddPolicy(kPolicyProxyServerMode, - Value::CreateIntegerValue( - kPolicyUseSystemProxyMode)); + provider->AddPolicy(kPolicyProxyPacUrl, + Value::CreateStringValue("http://short.org/proxy.pac")); + provider->AddPolicy(kPolicyProxyMode, + Value::CreateIntegerValue(kPolicyAutoDetectProxyMode)); ConfigurationPolicyPrefStore store(provider.get()); - - std::string string_result; - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList, - &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result)); - bool bool_result; - EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result)); - EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, - &bool_result)); + VerifyProxyPrefs( + store, "", "http://short.org/proxy.pac", "", ProxyPrefs::MODE_PAC_SCRIPT); } -TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemReversedApplyOrder) { +TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) { scoped_ptr<MockConfigurationPolicyProvider> provider( new MockConfigurationPolicyProvider()); - provider->AddPolicy(kPolicyProxyServerMode, - Value::CreateIntegerValue( - kPolicyUseSystemProxyMode)); - provider->AddPolicy(kPolicyProxyBypassList, - Value::CreateStringValue("http://chromium.org/override")); + provider->AddPolicy(kPolicyProxyMode, + Value::CreateIntegerValue(kPolicyUseSystemProxyMode)); ConfigurationPolicyPrefStore store(provider.get()); + VerifyProxyPrefs(store, "", "", "", ProxyPrefs::MODE_SYSTEM); +} - std::string string_result; - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList, - &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result)); - EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result)); - bool bool_result; - EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result)); - EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, - &bool_result)); +TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) { + for (int i = 0; i < MODE_COUNT; ++i) { + scoped_ptr<MockConfigurationPolicyProvider> provider( + new MockConfigurationPolicyProvider()); + provider->AddPolicy(kPolicyProxyMode, Value::CreateIntegerValue(i)); + // No mode expects all three parameters being set. + provider->AddPolicy(kPolicyProxyPacUrl, + Value::CreateStringValue("http://short.org/proxy.pac")); + provider->AddPolicy(kPolicyProxyBypassList, + Value::CreateStringValue( + "http://chromium.org/override")); + provider->AddPolicy(kPolicyProxyServer, + Value::CreateStringValue("chromium.org")); + + ConfigurationPolicyPrefStore store(provider.get()); + EXPECT_FALSE(store.prefs()->HasKey(prefs::kProxyMode)); + } } class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test { diff --git a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc index 5690375..345a3f6 100644 --- a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc +++ b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc @@ -233,8 +233,8 @@ INSTANTIATE_TEST_CASE_P( kPolicyDefaultSearchProviderEncodings, key::kDefaultSearchProviderEncodings), PolicyTestParams::ForIntegerPolicy( - kPolicyProxyServerMode, - key::kProxyServerMode), + kPolicyProxyMode, + key::kProxyMode), PolicyTestParams::ForStringPolicy( kPolicyProxyServer, key::kProxyServer), diff --git a/chrome/browser/policy/configuration_policy_provider_win_unittest.cc b/chrome/browser/policy/configuration_policy_provider_win_unittest.cc index 78c6f7b..beed450 100644 --- a/chrome/browser/policy/configuration_policy_provider_win_unittest.cc +++ b/chrome/browser/policy/configuration_policy_provider_win_unittest.cc @@ -391,8 +391,8 @@ INSTANTIATE_TEST_CASE_P( kPolicyDefaultSearchProviderEncodings, key::kDefaultSearchProviderEncodings), PolicyTestParams::ForIntegerPolicy( - kPolicyProxyServerMode, - key::kProxyServerMode), + kPolicyProxyMode, + key::kProxyMode), PolicyTestParams::ForStringPolicy( kPolicyProxyServer, key::kProxyServer), diff --git a/chrome/browser/policy/configuration_policy_store_interface.h b/chrome/browser/policy/configuration_policy_store_interface.h index 00ebf30..b6d1f3b 100644 --- a/chrome/browser/policy/configuration_policy_store_interface.h +++ b/chrome/browser/policy/configuration_policy_store_interface.h @@ -25,7 +25,7 @@ enum ConfigurationPolicyType { kPolicyDefaultSearchProviderIconURL, kPolicyDefaultSearchProviderEncodings, kPolicyDisableSpdy, - kPolicyProxyServerMode, + kPolicyProxyMode, kPolicyProxyServer, kPolicyProxyPacUrl, kPolicyProxyBypassList, @@ -69,10 +69,24 @@ enum ConfigurationPolicyType { kPolicyDisable3DAPIs }; -static const int kPolicyNoProxyServerMode = 0; -static const int kPolicyAutoDetectProxyMode = 1; -static const int kPolicyManuallyConfiguredProxyMode = 2; -static const int kPolicyUseSystemProxyMode = 3; + +// Constants for the "Proxy Server Mode" defined in the policies. +// Note that these diverge from internal presentation defined in +// ProxyPrefs::ProxyMode for legacy reasons. The following four +// PolicyProxyModeType types were not very precise and had overlapping use +// cases. +enum PolicyProxyModeType { + // Disable Proxy, connect directly. + kPolicyNoProxyServerMode = 0, + // Auto detect proxy or use specific PAC script if given. + kPolicyAutoDetectProxyMode = 1, + // Use manually configured proxy servers (fixed servers). + kPolicyManuallyConfiguredProxyMode = 2, + // Use system proxy server. + kPolicyUseSystemProxyMode = 3, + + MODE_COUNT +}; // An abstract super class for policy stores that provides a method that can be // called by a |ConfigurationPolicyProvider| to specify a policy. diff --git a/chrome/browser/policy/managed_prefs_banner_base.cc b/chrome/browser/policy/managed_prefs_banner_base.cc index 1351da4..7c20a09 100644 --- a/chrome/browser/policy/managed_prefs_banner_base.cc +++ b/chrome/browser/policy/managed_prefs_banner_base.cc @@ -84,8 +84,7 @@ void ManagedPrefsBannerBase::Init(PrefService* local_state, #if defined(GOOGLE_CHROME_BUILD) AddLocalStatePref(prefs::kMetricsReportingEnabled); #endif - AddUserPref(prefs::kNoProxyServer); - AddUserPref(prefs::kProxyAutoDetect); + AddUserPref(prefs::kProxyMode); AddUserPref(prefs::kProxyServer); AddUserPref(prefs::kProxyPacUrl); AddUserPref(prefs::kProxyBypassList); diff --git a/chrome/browser/prefs/command_line_pref_store.cc b/chrome/browser/prefs/command_line_pref_store.cc index ae70d97..4a386d6 100644 --- a/chrome/browser/prefs/command_line_pref_store.cc +++ b/chrome/browser/prefs/command_line_pref_store.cc @@ -7,6 +7,7 @@ #include "app/app_switches.h" #include "base/logging.h" #include "base/values.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/pref_names.h" @@ -25,8 +26,6 @@ const CommandLinePrefStore::StringSwitchToPreferenceMapEntry const CommandLinePrefStore::BooleanSwitchToPreferenceMapEntry CommandLinePrefStore::boolean_switch_map_[] = { - { switches::kNoProxyServer, prefs::kNoProxyServer, true }, - { switches::kProxyAutoDetect, prefs::kProxyAutoDetect, true }, { switches::kDisableAuthNegotiateCnameLookup, prefs::kDisableAuthNegotiateCnameLookup, true }, { switches::kEnableAuthNegotiatePort, prefs::kEnableAuthNegotiatePort, @@ -37,6 +36,7 @@ const CommandLinePrefStore::BooleanSwitchToPreferenceMapEntry CommandLinePrefStore::CommandLinePrefStore(const CommandLine* command_line) : command_line_(command_line) { ApplySimpleSwitches(); + ApplyProxyMode(); ValidateProxySwitches(); } @@ -73,3 +73,19 @@ bool CommandLinePrefStore::ValidateProxySwitches() { } return true; } + +void CommandLinePrefStore::ApplyProxyMode() { + if (command_line_->HasSwitch(switches::kNoProxyServer)) { + SetValue(prefs::kProxyMode, + Value::CreateIntegerValue(ProxyPrefs::MODE_DIRECT)); + } else if (command_line_->HasSwitch(switches::kProxyPacUrl)) { + SetValue(prefs::kProxyMode, + Value::CreateIntegerValue(ProxyPrefs::MODE_PAC_SCRIPT)); + } else if (command_line_->HasSwitch(switches::kProxyAutoDetect)) { + SetValue(prefs::kProxyMode, + Value::CreateIntegerValue(ProxyPrefs::MODE_AUTO_DETECT)); + } else if (command_line_->HasSwitch(switches::kProxyServer)) { + SetValue(prefs::kProxyMode, + Value::CreateIntegerValue(ProxyPrefs::MODE_FIXED_SERVERS)); + } +} diff --git a/chrome/browser/prefs/command_line_pref_store.h b/chrome/browser/prefs/command_line_pref_store.h index c3baf7a..75d8b10 100644 --- a/chrome/browser/prefs/command_line_pref_store.h +++ b/chrome/browser/prefs/command_line_pref_store.h @@ -45,6 +45,9 @@ class CommandLinePrefStore : public ValueMapPrefStore { // corresponding preferences in this pref store. void ApplySimpleSwitches(); + // Determines the proxy mode preference from the given proxy switches. + void ApplyProxyMode(); + // Weak reference. const CommandLine* command_line_; diff --git a/chrome/browser/prefs/command_line_pref_store_unittest.cc b/chrome/browser/prefs/command_line_pref_store_unittest.cc index 031a7c9..1be9c0a 100644 --- a/chrome/browser/prefs/command_line_pref_store_unittest.cc +++ b/chrome/browser/prefs/command_line_pref_store_unittest.cc @@ -9,6 +9,7 @@ #include "base/string_util.h" #include "base/values.h" #include "chrome/browser/prefs/command_line_pref_store.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/pref_names.h" @@ -22,6 +23,12 @@ class TestCommandLinePrefStore : public CommandLinePrefStore { bool ProxySwitchesAreValid() { return ValidateProxySwitches(); } + + void VerifyIntPref(const std::string& path, int expected_value) { + Value* actual = NULL; + ASSERT_EQ(PrefStore::READ_OK, GetValue(path, &actual)); + EXPECT_TRUE(FundamentalValue(expected_value).Equals(actual)); + } }; const char unknown_bool[] = "unknown_switch"; @@ -47,13 +54,9 @@ TEST(CommandLinePrefStoreTest, SimpleStringPref) { TEST(CommandLinePrefStoreTest, SimpleBooleanPref) { CommandLine cl(CommandLine::NO_PROGRAM); cl.AppendSwitch(switches::kNoProxyServer); - CommandLinePrefStore store(&cl); + TestCommandLinePrefStore store(&cl); - Value* actual = NULL; - ASSERT_EQ(PrefStore::READ_OK, store.GetValue(prefs::kNoProxyServer, &actual)); - bool result; - EXPECT_TRUE(actual->GetAsBoolean(&result)); - EXPECT_TRUE(result); + store.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_DIRECT); } // Tests a command line with no recognized prefs. @@ -76,15 +79,11 @@ TEST(CommandLinePrefStoreTest, MultipleSwitches) { cl.AppendSwitchASCII(switches::kProxyServer, "proxy"); cl.AppendSwitchASCII(switches::kProxyBypassList, "list"); cl.AppendSwitchASCII(unknown_bool, "a value"); - CommandLinePrefStore store(&cl); + TestCommandLinePrefStore store(&cl); Value* actual = NULL; EXPECT_EQ(PrefStore::READ_NO_VALUE, store.GetValue(unknown_bool, &actual)); - ASSERT_EQ(PrefStore::READ_OK, - store.GetValue(prefs::kProxyAutoDetect, &actual)); - bool bool_result = false; - EXPECT_TRUE(actual->GetAsBoolean(&bool_result)); - EXPECT_TRUE(bool_result); + store.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_AUTO_DETECT); EXPECT_EQ(PrefStore::READ_NO_VALUE, store.GetValue(unknown_string, &actual)); std::string string_result = ""; @@ -124,3 +123,16 @@ TEST(CommandLinePrefStoreTest, ProxySwitchValidation) { TestCommandLinePrefStore store4(&cl2); EXPECT_TRUE(store4.ProxySwitchesAreValid()); } + +TEST(CommandLinePrefStoreTest, ManualProxyModeInference) { + CommandLine cl1(CommandLine::NO_PROGRAM); + cl1.AppendSwitch(unknown_string); + cl1.AppendSwitchASCII(switches::kProxyServer, "proxy"); + TestCommandLinePrefStore store1(&cl1); + store1.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_FIXED_SERVERS); + + CommandLine cl2(CommandLine::NO_PROGRAM); + cl2.AppendSwitchASCII(switches::kProxyPacUrl, "proxy"); + TestCommandLinePrefStore store2(&cl2); + store2.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_PAC_SCRIPT); +} diff --git a/chrome/browser/prefs/pref_service_unittest.cc b/chrome/browser/prefs/pref_service_unittest.cc index 8ada07a..1a79708 100644 --- a/chrome/browser/prefs/pref_service_unittest.cc +++ b/chrome/browser/prefs/pref_service_unittest.cc @@ -16,6 +16,7 @@ #include "chrome/browser/prefs/pref_observer_mock.h" #include "chrome/browser/prefs/pref_service_mock_builder.h" #include "chrome/browser/prefs/pref_value_store.h" +#include "chrome/browser/prefs/proxy_prefs.h" #include "chrome/browser/prefs/testing_pref_store.h" #include "chrome/common/chrome_paths.h" #include "chrome/common/chrome_switches.h" @@ -150,17 +151,14 @@ TEST(PrefServiceTest, Observers) { TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineOptions) { CommandLine command_line(CommandLine::NO_PROGRAM); command_line.AppendSwitchASCII(switches::kProxyBypassList, "123"); - command_line.AppendSwitchASCII(switches::kProxyPacUrl, "456"); command_line.AppendSwitchASCII(switches::kProxyServer, "789"); scoped_ptr<policy::MockConfigurationPolicyProvider> provider( new policy::MockConfigurationPolicyProvider()); Value* mode_value = Value::CreateIntegerValue( policy::kPolicyManuallyConfiguredProxyMode); - provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value); + provider->AddPolicy(policy::kPolicyProxyMode, mode_value); provider->AddPolicy(policy::kPolicyProxyBypassList, Value::CreateStringValue("abc")); - provider->AddPolicy(policy::kPolicyProxyPacUrl, - Value::CreateStringValue("def")); provider->AddPolicy(policy::kPolicyProxyServer, Value::CreateStringValue("ghi")); @@ -170,10 +168,10 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineOptions) { builder.WithCommandLine(&command_line); scoped_ptr<PrefService> prefs(builder.Create()); browser::RegisterUserPrefs(prefs.get()); - EXPECT_FALSE(prefs->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_FALSE(prefs->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, + prefs->GetInteger(prefs::kProxyMode)); EXPECT_EQ("789", prefs->GetString(prefs::kProxyServer)); - EXPECT_EQ("456", prefs->GetString(prefs::kProxyPacUrl)); + EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyPacUrl)); EXPECT_EQ("123", prefs->GetString(prefs::kProxyBypassList)); // Try a second time time with the managed PrefStore in place, the @@ -183,23 +181,22 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineOptions) { builder.WithManagedPlatformProvider(provider.get()); scoped_ptr<PrefService> prefs2(builder.Create()); browser::RegisterUserPrefs(prefs2.get()); - EXPECT_FALSE(prefs2->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_FALSE(prefs2->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, + prefs2->GetInteger(prefs::kProxyMode)); EXPECT_EQ("ghi", prefs2->GetString(prefs::kProxyServer)); - EXPECT_EQ("def", prefs2->GetString(prefs::kProxyPacUrl)); + EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl)); EXPECT_EQ("abc", prefs2->GetString(prefs::kProxyBypassList)); } TEST(PrefServiceTest, ProxyPolicyOverridesUnrelatedCommandLineOptions) { CommandLine command_line(CommandLine::NO_PROGRAM); command_line.AppendSwitchASCII(switches::kProxyBypassList, "123"); - command_line.AppendSwitchASCII(switches::kProxyPacUrl, "456"); command_line.AppendSwitchASCII(switches::kProxyServer, "789"); scoped_ptr<policy::MockConfigurationPolicyProvider> provider( new policy::MockConfigurationPolicyProvider()); Value* mode_value = Value::CreateIntegerValue( - policy::kPolicyUseSystemProxyMode); - provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value); + policy::kPolicyAutoDetectProxyMode); + provider->AddPolicy(policy::kPolicyProxyMode, mode_value); // First verify that command-line options are set correctly when // there is no policy in effect. @@ -207,10 +204,9 @@ TEST(PrefServiceTest, ProxyPolicyOverridesUnrelatedCommandLineOptions) { builder.WithCommandLine(&command_line); scoped_ptr<PrefService> prefs(builder.Create()); browser::RegisterUserPrefs(prefs.get()); - EXPECT_FALSE(prefs->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_FALSE(prefs->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, + prefs->GetInteger(prefs::kProxyMode)); EXPECT_EQ("789", prefs->GetString(prefs::kProxyServer)); - EXPECT_EQ("456", prefs->GetString(prefs::kProxyPacUrl)); EXPECT_EQ("123", prefs->GetString(prefs::kProxyBypassList)); // Try a second time time with the managed PrefStore in place, the @@ -221,8 +217,8 @@ TEST(PrefServiceTest, ProxyPolicyOverridesUnrelatedCommandLineOptions) { builder.WithManagedPlatformProvider(provider.get()); scoped_ptr<PrefService> prefs2(builder.Create()); browser::RegisterUserPrefs(prefs2.get()); - EXPECT_FALSE(prefs2->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_FALSE(prefs2->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, + prefs2->GetInteger(prefs::kProxyMode)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyServer)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyBypassList)); @@ -235,7 +231,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineNoProxy) { new policy::MockConfigurationPolicyProvider()); Value* mode_value = Value::CreateIntegerValue( policy::kPolicyAutoDetectProxyMode); - provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value); + provider->AddPolicy(policy::kPolicyProxyMode, mode_value); // First verify that command-line options are set correctly when // there is no policy in effect. @@ -243,8 +239,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineNoProxy) { builder.WithCommandLine(&command_line); scoped_ptr<PrefService> prefs(builder.Create()); browser::RegisterUserPrefs(prefs.get()); - EXPECT_FALSE(prefs->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_TRUE(prefs->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_DIRECT, prefs->GetInteger(prefs::kProxyMode)); EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyServer)); EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyPacUrl)); EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyBypassList)); @@ -256,8 +251,8 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineNoProxy) { builder.WithManagedPlatformProvider(provider.get()); scoped_ptr<PrefService> prefs2(builder.Create()); browser::RegisterUserPrefs(prefs2.get()); - EXPECT_TRUE(prefs2->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_FALSE(prefs2->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, + prefs2->GetInteger(prefs::kProxyMode)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyServer)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyBypassList)); @@ -270,7 +265,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineAutoDetect) { new policy::MockConfigurationPolicyProvider()); Value* mode_value = Value::CreateIntegerValue( policy::kPolicyNoProxyServerMode); - provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value); + provider->AddPolicy(policy::kPolicyProxyMode, mode_value); // First verify that the auto-detect is set if there is no managed // PrefStore. @@ -278,8 +273,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineAutoDetect) { builder.WithCommandLine(&command_line); scoped_ptr<PrefService> prefs(builder.Create()); browser::RegisterUserPrefs(prefs.get()); - EXPECT_TRUE(prefs->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_FALSE(prefs->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, prefs->GetInteger(prefs::kProxyMode)); EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyServer)); EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyPacUrl)); EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyBypassList)); @@ -291,8 +285,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineAutoDetect) { builder.WithManagedPlatformProvider(provider.get()); scoped_ptr<PrefService> prefs2(builder.Create()); browser::RegisterUserPrefs(prefs2.get()); - EXPECT_FALSE(prefs2->GetBoolean(prefs::kProxyAutoDetect)); - EXPECT_TRUE(prefs2->GetBoolean(prefs::kNoProxyServer)); + EXPECT_EQ(ProxyPrefs::MODE_DIRECT, prefs2->GetInteger(prefs::kProxyMode)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyServer)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl)); EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyBypassList)); diff --git a/chrome/browser/prefs/pref_set_observer.cc b/chrome/browser/prefs/pref_set_observer.cc index a073eb2..133b219 100644 --- a/chrome/browser/prefs/pref_set_observer.cc +++ b/chrome/browser/prefs/pref_set_observer.cc @@ -47,8 +47,7 @@ PrefSetObserver* PrefSetObserver::CreateProxyPrefSetObserver( PrefService* pref_service, NotificationObserver* observer) { PrefSetObserver* pref_set = new PrefSetObserver(pref_service, observer); - pref_set->AddPref(prefs::kNoProxyServer); - pref_set->AddPref(prefs::kProxyAutoDetect); + pref_set->AddPref(prefs::kProxyMode); pref_set->AddPref(prefs::kProxyServer); pref_set->AddPref(prefs::kProxyPacUrl); pref_set->AddPref(prefs::kProxyBypassList); diff --git a/chrome/browser/prefs/pref_value_store_unittest.cc b/chrome/browser/prefs/pref_value_store_unittest.cc index 5649061..b78e0fc 100644 --- a/chrome/browser/prefs/pref_value_store_unittest.cc +++ b/chrome/browser/prefs/pref_value_store_unittest.cc @@ -133,8 +133,8 @@ class PrefValueStoreTest : public testing::Test { Value::TYPE_LIST); pref_value_store_->RegisterPreferenceType(prefs::kDefaultPref, Value::TYPE_INTEGER); - pref_value_store_->RegisterPreferenceType(prefs::kProxyAutoDetect, - Value::TYPE_BOOLEAN); + pref_value_store_->RegisterPreferenceType(prefs::kProxyMode, + Value::TYPE_INTEGER); } // Creates a new dictionary and stores some sample user preferences diff --git a/chrome/browser/prefs/proxy_prefs.cc b/chrome/browser/prefs/proxy_prefs.cc new file mode 100644 index 0000000..7eb504c --- /dev/null +++ b/chrome/browser/prefs/proxy_prefs.cc @@ -0,0 +1,45 @@ +// 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. + +#include "chrome/browser/prefs/proxy_prefs.h" + +#include "base/basictypes.h" +#include "base/logging.h" + +namespace { + +// These names are exposed to the proxy extension API. They must be in sync +// with the constants of ProxyPrefs. +const char* kProxyModeNames[] = { "direct", + "auto_detect", + "pac_script", + "fixed_servers", + "system" }; + +} // namespace + +namespace ProxyPrefs { + +COMPILE_ASSERT(arraysize(kProxyModeNames) == kModeCount, + kProxyModeNames_must_have_size_of_NUM_MODES); + +bool IntToProxyMode(int in_value, ProxyMode* out_value) { + DCHECK(out_value); + if (in_value < 0 || in_value >= kModeCount) + return false; + *out_value = static_cast<ProxyMode>(in_value); + return true; +} + +// static +bool StringToProxyMode(const std::string& in_value, ProxyMode* out_value) { + DCHECK(out_value); + for (int i = 0; i < kModeCount; i++) { + if (in_value == kProxyModeNames[i]) + return IntToProxyMode(i, out_value); + } + return false; +} + +} // namespace diff --git a/chrome/browser/prefs/proxy_prefs.h b/chrome/browser/prefs/proxy_prefs.h new file mode 100644 index 0000000..bbeb44d --- /dev/null +++ b/chrome/browser/prefs/proxy_prefs.h @@ -0,0 +1,45 @@ +// 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. + +#ifndef CHROME_BROWSER_PREFS_PROXY_PREFS_H_ +#define CHROME_BROWSER_PREFS_PROXY_PREFS_H_ +#pragma once + +#include <string> + +namespace ProxyPrefs { + +// Possible types of specifying proxy settings. Do not change the order of +// the constants, because numeric values are exposed to users. +// If you add an enum constant, you should also add a string to +// kProxyModeNames in the .cc file. +enum ProxyMode { + // Direct connection to the network, other proxy preferences are ignored. + MODE_DIRECT = 0, + + // Try to retrieve a PAC script from http://wpad/wpad.dat or fall back to + // direct connection. + MODE_AUTO_DETECT = 1, + + // Try to retrieve a PAC script from kProxyPacURL or fall back to direct + // connection. + MODE_PAC_SCRIPT = 2, + + // Use the settings specified in kProxyServer and kProxyBypassList. + MODE_FIXED_SERVERS = 3, + + // The system's proxy settings are used, other proxy preferences are + // ignored. + MODE_SYSTEM = 4, + + kModeCount +}; + +bool IntToProxyMode(int in_value, ProxyMode* out_value); +bool StringToProxyMode(const std::string& in_value, + ProxyMode* out_value); + +} // namespace ProxyPrefs + +#endif // CHROME_BROWSER_PREFS_PROXY_PREFS_H_ diff --git a/chrome/browser/prefs/proxy_prefs_unittest.cc b/chrome/browser/prefs/proxy_prefs_unittest.cc new file mode 100644 index 0000000..72aa0f1 --- /dev/null +++ b/chrome/browser/prefs/proxy_prefs_unittest.cc @@ -0,0 +1,52 @@ +// 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. + +#include <string> + +#include "base/logging.h" +#include "base/values.h" +#include "base/version.h" +#include "chrome/browser/prefs/proxy_prefs.h" +#include "testing/gtest/include/gtest/gtest.h" + +TEST(ProxyPrefsTest, StringToProxyMode) { + ProxyPrefs::ProxyMode mode; + EXPECT_TRUE(ProxyPrefs::StringToProxyMode("direct", &mode)); + EXPECT_EQ(ProxyPrefs::MODE_DIRECT, mode); + EXPECT_TRUE(ProxyPrefs::StringToProxyMode("auto_detect", &mode)); + EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, mode); + EXPECT_TRUE(ProxyPrefs::StringToProxyMode("pac_script", &mode)); + EXPECT_EQ(ProxyPrefs::MODE_PAC_SCRIPT, mode); + EXPECT_TRUE(ProxyPrefs::StringToProxyMode("system", &mode)); + EXPECT_EQ(ProxyPrefs::MODE_SYSTEM, mode); + EXPECT_TRUE(ProxyPrefs::StringToProxyMode("fixed_servers", &mode)); + EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, mode); + + EXPECT_FALSE(ProxyPrefs::StringToProxyMode("monkey", &mode)); +} + +TEST(ProxyPrefsTest, IntToProxyMode) { + ASSERT_EQ(ProxyPrefs::MODE_DIRECT, 0); + ASSERT_EQ(ProxyPrefs::MODE_AUTO_DETECT, 1); + ASSERT_EQ(ProxyPrefs::MODE_PAC_SCRIPT, 2); + ASSERT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, 3); + ASSERT_EQ(ProxyPrefs::MODE_SYSTEM, 4); + // Update the following as necessary, don't change the previous ones. + ASSERT_EQ(ProxyPrefs::kModeCount, 5); + + ProxyPrefs::ProxyMode mode; + EXPECT_TRUE(ProxyPrefs::IntToProxyMode(0, &mode)); + EXPECT_EQ(ProxyPrefs::MODE_DIRECT, mode); + EXPECT_TRUE(ProxyPrefs::IntToProxyMode(1, &mode)); + EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, mode); + EXPECT_TRUE(ProxyPrefs::IntToProxyMode(2, &mode)); + EXPECT_EQ(ProxyPrefs::MODE_PAC_SCRIPT, mode); + EXPECT_TRUE(ProxyPrefs::IntToProxyMode(3, &mode)); + EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, mode); + EXPECT_TRUE(ProxyPrefs::IntToProxyMode(4, &mode)); + EXPECT_EQ(ProxyPrefs::MODE_SYSTEM, mode); + + EXPECT_FALSE(ProxyPrefs::IntToProxyMode(-1, &mode)); + EXPECT_FALSE(ProxyPrefs::IntToProxyMode(ProxyPrefs::kModeCount, &mode)); +} diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi index 153568d..8a0dba9 100644 --- a/chrome/chrome_browser.gypi +++ b/chrome/chrome_browser.gypi @@ -2051,6 +2051,8 @@ 'browser/prefs/pref_value_map.h', 'browser/prefs/pref_value_store.cc', 'browser/prefs/pref_value_store.h', + 'browser/prefs/proxy_prefs.cc', + 'browser/prefs/proxy_prefs.h', 'browser/prefs/scoped_pref_update.cc', 'browser/prefs/scoped_pref_update.h', 'browser/prefs/session_startup_pref.cc', diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi index c0d7729..3c50a76 100644 --- a/chrome/chrome_tests.gypi +++ b/chrome/chrome_tests.gypi @@ -1281,6 +1281,7 @@ 'browser/prefs/pref_service_unittest.cc', 'browser/prefs/pref_set_observer_unittest.cc', 'browser/prefs/pref_value_store_unittest.cc', + 'browser/prefs/proxy_prefs_unittest.cc', 'browser/prefs/session_startup_pref_unittest.cc', 'browser/prerender/prerender_interceptor_unittest.cc', 'browser/prerender/prerender_manager_unittest.cc', diff --git a/chrome/common/extensions/api/extension_api.json b/chrome/common/extensions/api/extension_api.json index 4e34632..bda4b49 100644 --- a/chrome/common/extensions/api/extension_api.json +++ b/chrome/common/extensions/api/extension_api.json @@ -3636,8 +3636,12 @@ "description": "An object encapsulating a complete proxy configuration.", "properties": { "rules": {"$ref": "ProxyRules", "optional": true, "description": "The proxy rules describing this configuration."}, - "autoDetect": {"type": "boolean", "optional": true, "description": "True if the proxy settings sbould be detected automatically."}, - "pacScript": {"$ref": "PacScript", "optional": true, "description": "The proxy auto-config (PAC) script for this configuration."} + "pacScript": {"$ref": "PacScript", "optional": true, "description": "The proxy auto-config (PAC) script for this configuration."}, + "mode": { + "type": "string", + "enum": ["direct", "auto_detect", "pac_script", "fixed_servers", "system"], + "description": "'direct' = Never use a proxy<br>'auto_detect' = Auto detect proxy settings<br>'pac_script' = Use specified PAC script<br>'fixed_servers' = Manually specify proxy servers<br>'system' = Use system proxy settings" + } } } ], diff --git a/chrome/common/extensions/docs/examples/extensions/imageinfo.zip b/chrome/common/extensions/docs/examples/extensions/imageinfo.zip Binary files differindex cec9f93..dbce95b 100644 --- a/chrome/common/extensions/docs/examples/extensions/imageinfo.zip +++ b/chrome/common/extensions/docs/examples/extensions/imageinfo.zip diff --git a/chrome/common/extensions/docs/experimental.proxy.html b/chrome/common/extensions/docs/experimental.proxy.html index 3f97065..a13ce9e 100644 --- a/chrome/common/extensions/docs/experimental.proxy.html +++ b/chrome/common/extensions/docs/experimental.proxy.html @@ -1314,7 +1314,7 @@ </div><div> <div> <dt> - <var>autoDetect</var> + <var>pacScript</var> <em> <!-- TYPE --> @@ -1323,15 +1323,15 @@ <span class="optional">optional</span> <span class="enum" style="display: none; ">enumerated</span> <span id="typeTemplate"> - <span style="display: none; "> - <a> Type</a> - </span> <span> - <span style="display: none; "> + <a href="experimental.proxy.html#type-PacScript">PacScript</a> + </span> + <span style="display: none; "> + <span> array of <span><span></span></span> </span> - <span>boolean</span> - <span style="display: none; "></span> + <span>paramType</span> + <span></span> </span> </span> ) @@ -1342,7 +1342,7 @@ <dd class="todo" style="display: none; "> Undocumented. </dd> - <dd>True if the proxy settings sbould be detected automatically.</dd> + <dd>The proxy auto-config (PAC) script for this configuration.</dd> <dd style="display: none; "> This parameter was added in version <b><span></span></b>. @@ -1372,24 +1372,24 @@ </div><div> <div> <dt> - <var>pacScript</var> + <var>mode</var> <em> <!-- TYPE --> <div style="display:inline"> ( - <span class="optional">optional</span> - <span class="enum" style="display: none; ">enumerated</span> + <span class="optional" style="display: none; ">optional</span> + <span class="enum">enumerated</span> <span id="typeTemplate"> - <span> - <a href="experimental.proxy.html#type-PacScript">PacScript</a> - </span> <span style="display: none; "> - <span> + <a> Type</a> + </span> + <span> + <span style="display: none; "> array of <span><span></span></span> </span> - <span>paramType</span> - <span></span> + <span>string</span> + <span>["direct", "auto_detect", "pac_script", "fixed_servers", "system"]</span> </span> </span> ) @@ -1400,7 +1400,7 @@ <dd class="todo" style="display: none; "> Undocumented. </dd> - <dd>The proxy auto-config (PAC) script for this configuration.</dd> + <dd>'direct' = Never use a proxy<br>'auto_detect' = Auto detect proxy settings<br>'pac_script' = Use specified PAC script<br>'fixed_servers' = Manually specify proxy servers<br>'system' = Use system proxy settings</dd> <dd style="display: none; "> This parameter was added in version <b><span></span></b>. diff --git a/chrome/common/extensions/docs/samples.json b/chrome/common/extensions/docs/samples.json index ebd74bb..9e70b0c 100644 --- a/chrome/common/extensions/docs/samples.json +++ b/chrome/common/extensions/docs/samples.json @@ -941,7 +941,7 @@ "info.html", "manifest.json" ], - "source_hash": "672f49ed8edbe0829c7ba5a1d890b4440b157991", + "source_hash": "c746d9114348f4b414c1ec05e988e2807feb963a", "zip_path": "examples/extensions/imageinfo.zip" }, { diff --git a/chrome/common/policy_constants.cc b/chrome/common/policy_constants.cc index 300b450..8ed8934 100644 --- a/chrome/common/policy_constants.cc +++ b/chrome/common/policy_constants.cc @@ -32,7 +32,10 @@ const char kDefaultSearchProviderIconURL[] = const char kDefaultSearchProviderEncodings[] = "DefaultSearchProviderEncodings"; const char kDisableSpdy[] = "DisableSpdy"; -const char kProxyServerMode[] = "ProxyServerMode"; +// We consider the name ProxyMode more apt than ProxyServerMode but could +// not change it after publishing that name for the win registry and policy +// config files. +const char kProxyMode[] = "ProxyServerMode"; const char kProxyServer[] = "ProxyServer"; const char kProxyPacUrl[] = "ProxyPacUrl"; const char kProxyBypassList[] = "ProxyBypassList"; diff --git a/chrome/common/policy_constants.h b/chrome/common/policy_constants.h index a1e2a83..279197e 100644 --- a/chrome/common/policy_constants.h +++ b/chrome/common/policy_constants.h @@ -30,7 +30,7 @@ extern const char kDefaultSearchProviderSuggestURL[]; extern const char kDefaultSearchProviderIconURL[]; extern const char kDefaultSearchProviderEncodings[]; extern const char kDisableSpdy[]; -extern const char kProxyServerMode[]; +extern const char kProxyMode[]; extern const char kProxyServer[]; extern const char kProxyPacUrl[]; extern const char kProxyBypassList[]; diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc index c4af1e1..3da0b2c 100644 --- a/chrome/common/pref_names.cc +++ b/chrome/common/pref_names.cc @@ -1135,11 +1135,10 @@ const char kCloudPrintPrintSystemSettings[] = // Used by the service process to determine if the remoting host is enabled. const char kRemotingHostEnabled[] = "remoting.host_enabled"; -// Boolean to disable proxy altogether. If true, other proxy -// preferences are ignored. -const char kNoProxyServer[] = "proxy.disabled"; -// Boolean specifying if proxy should be auto-detected. -const char kProxyAutoDetect[] = "proxy.auto_detect"; +// Integer to specify the type of proxy settings. +// See ProxyPrefs for possible values and interactions with the other proxy +// preferences. +const char kProxyMode[] = "proxy.mode"; // String specifying the proxy server. For a specification of the expected // syntax see net::ProxyConfig::ProxyRules::ParseFromString(). const char kProxyServer[] = "proxy.server"; diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h index 6e4a47d..0450a21 100644 --- a/chrome/common/pref_names.h +++ b/chrome/common/pref_names.h @@ -411,8 +411,7 @@ extern const char kCloudPrintPrintSystemSettings[]; extern const char kRemotingHasSetupCompleted[]; extern const char kRemotingHostEnabled[]; -extern const char kNoProxyServer[]; -extern const char kProxyAutoDetect[]; +extern const char kProxyMode[]; extern const char kProxyServer[]; extern const char kProxyPacUrl[]; extern const char kProxyBypassList[]; diff --git a/chrome/test/data/extensions/api_test/proxy/auto/test.js b/chrome/test/data/extensions/api_test/proxy/auto/test.js index 6e2687d..eb56d66 100644 --- a/chrome/test/data/extensions/api_test/proxy/auto/test.js +++ b/chrome/test/data/extensions/api_test/proxy/auto/test.js @@ -7,12 +7,8 @@ chrome.test.runTests([ function setAutoSettings() { - var pacScriptObject = { - url: "http://wpad/windows.pac" - }; var config = { - autoDetect: true, - pacScript: pacScriptObject + mode: "auto_detect", }; chrome.experimental.proxy.useCustomProxySettings(config); chrome.test.succeed(); diff --git a/chrome/test/data/extensions/api_test/proxy/direct/manifest.json b/chrome/test/data/extensions/api_test/proxy/direct/manifest.json new file mode 100644 index 0000000..ada15d1 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/direct/manifest.json @@ -0,0 +1,7 @@ +{ + "name": "chrome.proxy", + "version": "0.1", + "description": "end-to-end browser test for chrome.proxy API", + "background_page": "test.html", + "permissions": ["experimental", "proxy"] +} diff --git a/chrome/test/data/extensions/api_test/proxy/direct/test.html b/chrome/test/data/extensions/api_test/proxy/direct/test.html new file mode 100644 index 0000000..46f4d74 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/direct/test.html @@ -0,0 +1 @@ +<script src="test.js"></script> diff --git a/chrome/test/data/extensions/api_test/proxy/direct/test.js b/chrome/test/data/extensions/api_test/proxy/direct/test.js new file mode 100644 index 0000000..6567fbd8 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/direct/test.js @@ -0,0 +1,16 @@ +// 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. + +// proxy api test +// browser_tests.exe --gtest_filter=ExtensionApiTest.ProxyAutoSettings + +chrome.test.runTests([ + function setAutoSettings() { + var config = { + mode: "direct", + }; + chrome.experimental.proxy.useCustomProxySettings(config); + chrome.test.succeed(); + } +]); diff --git a/chrome/test/data/extensions/api_test/proxy/individual/test.js b/chrome/test/data/extensions/api_test/proxy/individual/test.js index 9368a9c..bf71d52c 100644 --- a/chrome/test/data/extensions/api_test/proxy/individual/test.js +++ b/chrome/test/data/extensions/api_test/proxy/individual/test.js @@ -3,7 +3,7 @@ // found in the LICENSE file. // proxy api test -// browser_tests.exe --gtest_filter=ExtensionApiTest.ProxyManualIndividual +// browser_tests.exe --gtest_filter=ExtensionApiTest.ProxyFixedIndividual chrome.test.runTests([ function setIndividualProxies() { @@ -31,7 +31,7 @@ chrome.test.runTests([ socksProxy: socksProxy, }; - var config = { rules: rules }; + var config = { rules: rules, mode: "fixed_servers" }; chrome.experimental.proxy.useCustomProxySettings(config); chrome.test.succeed(); } diff --git a/chrome/test/data/extensions/api_test/proxy/pac/manifest.json b/chrome/test/data/extensions/api_test/proxy/pac/manifest.json new file mode 100644 index 0000000..ada15d1 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/pac/manifest.json @@ -0,0 +1,7 @@ +{ + "name": "chrome.proxy", + "version": "0.1", + "description": "end-to-end browser test for chrome.proxy API", + "background_page": "test.html", + "permissions": ["experimental", "proxy"] +} diff --git a/chrome/test/data/extensions/api_test/proxy/pac/test.html b/chrome/test/data/extensions/api_test/proxy/pac/test.html new file mode 100644 index 0000000..46f4d74 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/pac/test.html @@ -0,0 +1 @@ +<script src="test.js"></script> diff --git a/chrome/test/data/extensions/api_test/proxy/pac/test.js b/chrome/test/data/extensions/api_test/proxy/pac/test.js new file mode 100644 index 0000000..d45319e --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/pac/test.js @@ -0,0 +1,20 @@ +// 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. + +// proxy api test +// browser_tests.exe --gtest_filter=ExtensionApiTest.ProxyPacScript + +chrome.test.runTests([ + function setAutoSettings() { + var pacScriptObject = { + url: "http://wpad/windows.pac" + }; + var config = { + mode: "pac_script", + pacScript: pacScriptObject + }; + chrome.experimental.proxy.useCustomProxySettings(config); + chrome.test.succeed(); + } +]); diff --git a/chrome/test/data/extensions/api_test/proxy/single/test.js b/chrome/test/data/extensions/api_test/proxy/single/test.js index a20fb31..9cc8502 100644 --- a/chrome/test/data/extensions/api_test/proxy/single/test.js +++ b/chrome/test/data/extensions/api_test/proxy/single/test.js @@ -3,7 +3,7 @@ // found in the LICENSE file. // proxy api test -// browser_tests.exe --gtest_filter=ExtensionApiTest.ProxyManualSingle +// browser_tests.exe --gtest_filter=ExtensionApiTest.ProxyFixedSingle chrome.test.runTests([ function setSingleProxy() { @@ -29,7 +29,7 @@ chrome.test.runTests([ socksProxy: socksProxy, }; - var config = { rules: rules }; + var config = { rules: rules, mode: "fixed_servers" }; chrome.experimental.proxy.useCustomProxySettings(config); chrome.test.succeed(); } diff --git a/chrome/test/data/extensions/api_test/proxy/system/manifest.json b/chrome/test/data/extensions/api_test/proxy/system/manifest.json new file mode 100644 index 0000000..ada15d1 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/system/manifest.json @@ -0,0 +1,7 @@ +{ + "name": "chrome.proxy", + "version": "0.1", + "description": "end-to-end browser test for chrome.proxy API", + "background_page": "test.html", + "permissions": ["experimental", "proxy"] +} diff --git a/chrome/test/data/extensions/api_test/proxy/system/test.html b/chrome/test/data/extensions/api_test/proxy/system/test.html new file mode 100644 index 0000000..46f4d74 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/system/test.html @@ -0,0 +1 @@ +<script src="test.js"></script> diff --git a/chrome/test/data/extensions/api_test/proxy/system/test.js b/chrome/test/data/extensions/api_test/proxy/system/test.js new file mode 100644 index 0000000..1910ca8 --- /dev/null +++ b/chrome/test/data/extensions/api_test/proxy/system/test.js @@ -0,0 +1,14 @@ +// 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. + +// proxy api test +// browser_tests.exe --gtest_filter=ExtensionApiTest.ProxySystem + +chrome.test.runTests([ + function setSystemProxy() { + var config = { mode: "system" }; + chrome.experimental.proxy.useCustomProxySettings(config); + chrome.test.succeed(); + } +]); |