# persistent IDs for all fields (but not for groups!) are needed. These are

# specified by the 'id' keys of each policy. NEVER CHANGE EXISTING IDs,

# because doing so would break the deployed wire format!

#

'policy_definitions': [

{

'caption': '''Default geolocation setting''',

'desc': '''Allows you to set whether websites are allowed to track the users' physical location. Tracking the users' physical location can be allowed by default, denied by default or the user can be asked everytime a website requests the pysical location.''',

},

],

},

{

// Support for embedding_patterns is not implemented yet.

DCHECK(requesting_url == embedding_url);

return GetNonDefaultContentSettings(requesting_url).settings[content_type];

// Resolve content settings with resource identifier.

// 1. Check for pattern that exactly match the url/host

// 1.1 In the content-settings-map

ContentSettingsType content_type,

const ResourceIdentifier& resource_identifier,

Rules* content_setting_rules) const {

DCHECK(content_setting_rules);

content_setting_rules->clear();

return output;

}

// static

ContentSetting BaseProvider::ClickToPlayFixup(ContentSettingsType content_type,

ContentSetting setting) {

// CONTENT_SETTING_DEFAULT values.

bool AllDefault(const ExtendedContentSettings& settings) const;

// TODO(markusheintz): LEGACY method. Will be removed in a future re-factoring

// step.

ContentSettings GetNonDefaultContentSettings(const GURL& url) const;

content_type_(CONTENT_SETTINGS_TYPE_COOKIES),

resource_identifier_(""),

setting_(CONTENT_SETTING_DEFAULT),

MockProvider::MockProvider(ContentSettingsPattern requesting_url_pattern,

ContentSettingsPattern embedding_url_pattern,

ContentSettingsType content_type,

ResourceIdentifier resource_identifier,

ContentSetting setting,

: requesting_url_pattern_(requesting_url_pattern),

embedding_url_pattern_(embedding_url_pattern),

content_type_(content_type),

resource_identifier_(resource_identifier),

setting_(setting),

MockProvider::~MockProvider() {}

setting_ = content_setting;

}

} // namespace content_settings

ContentSettingsType content_type,

ResourceIdentifier resource_identifier,

ContentSetting setting,

virtual ~MockProvider();

// ProviderInterface implementation

virtual ContentSetting GetContentSetting(

const GURL& requesting_url,

requesting_url_pattern_ = pattern;

}

return requesting_url_pattern_;

}

embedding_url_pattern_ = pattern;

}

return embedding_url_pattern_;

}

content_type_ = content_type;

}

return content_type_;

}

resource_identifier_ = resource_identifier;

}

return resource_identifier_;

}

setting_ = setting;

}

return setting_;

}

read_only_ = read_only;

}

return read_only_;

}

private:

ContentSettingsPattern requesting_url_pattern_;

ContentSettingsPattern embedding_url_pattern_;

ResourceIdentifier resource_identifier_;

ContentSetting setting_;

bool read_only_;

DISALLOW_COPY_AND_ASSIGN(MockProvider);

};

#include "chrome/browser/content_settings/content_settings_policy_provider.h"

#include <string>

#include "base/command_line.h"

#include "chrome/browser/browser_thread.h"

#include "chrome/common/notification_source.h"

#include "chrome/common/pref_names.h"

namespace {

// Base pref path of the prefs that contain the managed default content

NULL, // Not used for Notifications

};

} // namespace

namespace content_settings {

void PolicyDefaultProvider::ReadManagedDefaultSettings() {

for (size_t type = 0; type < arraysize(kPrefToManageType); ++type) {

if (kPrefToManageType[type] == NULL) {

continue;

}

UpdateManagedDefaultSetting(ContentSettingsType(type));

CONTENT_SETTING_DEFAULT);

}

} // namespace content_settings

// A content settings provider that takes its settings out of policies.

#include "base/basictypes.h"

#include "base/synchronization/lock.h"

#include "chrome/browser/content_settings/content_settings_provider.h"

#include "chrome/browser/prefs/pref_change_registrar.h"

#include "chrome/common/notification_observer.h"

#include "chrome/common/notification_registrar.h"

DISALLOW_COPY_AND_ASSIGN(PolicyDefaultProvider);

};

} // namespace content_settings

#endif // CHROME_BROWSER_CONTENT_SETTINGS_CONTENT_SETTINGS_POLICY_PROVIDER_H_

#include "chrome/browser/content_settings/content_settings_policy_provider.h"

#include "chrome/browser/browser_thread.h"

#include "chrome/browser/content_settings/stub_settings_observer.h"

#include "chrome/browser/prefs/pref_service.h"

#include "chrome/common/pref_names.h"

#include "chrome/common/url_constants.h"

#include "chrome/test/testing_browser_process_test.h"

#include "chrome/test/testing_pref_service.h"

#include "chrome/test/testing_profile.h"

#include "testing/gtest/include/gtest/gtest.h"

namespace content_settings {

EXPECT_EQ(2, observer.counter);

}

} // namespace content_settings

virtual ~ProviderInterface() {}

// Returns a single ContentSetting which applies to a given |requesting_url|,

// |embedding_url| pair or CONTENT_SETTING_DEFAULT, if no rule applies. For

// ContentSettingsTypes that require a resource identifier to be specified,

CONTENT_SETTINGS_TYPE_PLUGINS,

"java_plugin",

CONTENT_SETTING_BLOCK,

false);

EXPECT_EQ(CONTENT_SETTING_BLOCK, mock_provider.GetContentSetting(

url, url, CONTENT_SETTINGS_TYPE_PLUGINS, "java_plugin"));

EXPECT_EQ(CONTENT_SETTING_DEFAULT, mock_provider.GetContentSetting(

// The order in which the content settings providers are created is critical,

// as providers that are further up in the list (i.e. added earlier) override

// providers further down.

pref_change_registrar_.Init(prefs);

pref_change_registrar_.Add(prefs::kBlockThirdPartyCookies, this);

content_settings::PrefDefaultProvider::RegisterUserPrefs(prefs);

content_settings::PolicyDefaultProvider::RegisterUserPrefs(prefs);

content_settings::PrefProvider::RegisterUserPrefs(prefs);

}

ContentSetting HostContentSettingsMap::GetDefaultContentSetting(

ContentSetting setting = GetNonDefaultContentSetting(url,

content_type,

resource_identifier);

return GetDefaultContentSetting(content_type);

return setting;

}

++provider) {

provided_setting = (*provider)->GetContentSetting(

url, url, content_type, resource_identifier);

}

return provided_setting;

}

for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {

// A managed default content setting has the highest priority and hence

// will overwrite any previously set value.

output.settings[j] = GetDefaultContentSetting(ContentSettingsType(j));

}

}

++provider) {

// TODO(markusheintz): Only the rules that are applied should be collected.

// Merge rules.

(*provider)->GetAllContentSettingsRules(

}

// convert Rules to SettingsForOneType

prefs::kManagedDefaultPluginsSetting },

{ Value::TYPE_INTEGER, kPolicyDefaultPopupsSetting,

prefs::kManagedDefaultPopupsSetting },

{ Value::TYPE_INTEGER, kPolicyDefaultNotificationSetting,

prefs::kDesktopNotificationDefaultContentSetting },

{ Value::TYPE_INTEGER, kPolicyDefaultGeolocationSetting,

key::kDefaultNotificationSetting },

{ kPolicyDefaultGeolocationSetting, Value::TYPE_INTEGER,

key::kDefaultGeolocationSetting },

{ kPolicyAuthSchemes, Value::TYPE_STRING, key::kAuthSchemes },

{ kPolicyDisableAuthNegotiateCnameLookup, Value::TYPE_BOOLEAN,

key::kDisableAuthNegotiateCnameLookup },

const char kManagedDefaultPopupsSetting[] =

"profile.managed_default_content_settings.popups";

// Dictionary for storing the set of known background pages (keys are extension

// IDs of background page owners, value is a boolean that is true if the user

// needs to acknowledge this page.

extern const char kManagedDefaultPluginsSetting[];

extern const char kManagedDefaultPopupsSetting[];

#if defined(OS_CHROMEOS)

extern const char kSignedSettingsTempStorage[];

extern const char kHardwareKeyboardLayout[];