1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// Copyright (c) 2013 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/content_settings/content_settings_internal_extension_provider.h"
#include "chrome/browser/content_settings/content_settings_rule.h"
#include "chrome/browser/extensions/extension_host.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/common/chrome_notification_types.h"
#include "chrome/common/content_settings.h"
#include "chrome/common/content_settings_pattern.h"
#include "chrome/common/extensions/api/plugins/plugins_handler.h"
#include "chrome/common/extensions/extension.h"
#include "chrome/common/extensions/extension_set.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/notification_details.h"
#include "content/public/browser/notification_service.h"
#include "extensions/common/constants.h"
using extensions::UnloadedExtensionInfo;
namespace content_settings {
InternalExtensionProvider::InternalExtensionProvider(
ExtensionService* extension_service)
: registrar_(new content::NotificationRegistrar) {
// Whitelist all extensions loaded so far.
const ExtensionSet* extensions = extension_service->extensions();
for (ExtensionSet::const_iterator it = extensions->begin();
it != extensions->end(); ++it) {
if (extensions::PluginInfo::HasPlugins(*it))
SetContentSettingForExtension(*it, CONTENT_SETTING_ALLOW);
}
Profile* profile = extension_service->profile();
registrar_->Add(this, chrome::NOTIFICATION_EXTENSION_HOST_CREATED,
content::Source<Profile>(profile));
registrar_->Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
content::Source<Profile>(profile));
registrar_->Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
content::Source<Profile>(profile));
}
InternalExtensionProvider::~InternalExtensionProvider() {
DCHECK(!registrar_.get());
}
RuleIterator* InternalExtensionProvider::GetRuleIterator(
ContentSettingsType content_type,
const ResourceIdentifier& resource_identifier,
bool incognito) const {
return value_map_.GetRuleIterator(content_type, resource_identifier, &lock_);
}
bool InternalExtensionProvider::SetWebsiteSetting(
const ContentSettingsPattern& primary_pattern,
const ContentSettingsPattern& secondary_pattern,
ContentSettingsType content_type,
const ResourceIdentifier& resource_identifier,
Value* value) {
return false;
}
void InternalExtensionProvider::ClearAllContentSettingsRules(
ContentSettingsType content_type) {}
void InternalExtensionProvider::Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) {
switch (type) {
case chrome::NOTIFICATION_EXTENSION_HOST_CREATED: {
const extensions::ExtensionHost* host =
content::Details<extensions::ExtensionHost>(details).ptr();
if (host->extension()->is_platform_app())
SetContentSettingForExtension(host->extension(), CONTENT_SETTING_BLOCK);
break;
}
case chrome::NOTIFICATION_EXTENSION_LOADED: {
const extensions::Extension* extension =
content::Details<extensions::Extension>(details).ptr();
if (extensions::PluginInfo::HasPlugins(extension))
SetContentSettingForExtension(extension, CONTENT_SETTING_ALLOW);
break;
}
case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
const UnloadedExtensionInfo& info =
*(content::Details<UnloadedExtensionInfo>(details).ptr());
if (extensions::PluginInfo::HasPlugins(info.extension))
SetContentSettingForExtension(info.extension, CONTENT_SETTING_DEFAULT);
break;
}
default:
NOTREACHED();
}
}
void InternalExtensionProvider::ShutdownOnUIThread() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
RemoveAllObservers();
registrar_.reset();
}
void InternalExtensionProvider::SetContentSettingForExtension(
const extensions::Extension* extension,
ContentSetting setting) {
scoped_ptr<ContentSettingsPattern::BuilderInterface> pattern_builder(
ContentSettingsPattern::CreateBuilder(false));
pattern_builder->WithScheme(extensions::kExtensionScheme);
pattern_builder->WithHost(extension->id());
pattern_builder->WithPathWildcard();
ContentSettingsPattern primary_pattern = pattern_builder->Build();
ContentSettingsPattern secondary_pattern = ContentSettingsPattern::Wildcard();
{
base::AutoLock lock(lock_);
if (setting == CONTENT_SETTING_DEFAULT) {
value_map_.DeleteValue(primary_pattern,
secondary_pattern,
CONTENT_SETTINGS_TYPE_PLUGINS,
ResourceIdentifier());
} else {
value_map_.SetValue(primary_pattern,
secondary_pattern,
CONTENT_SETTINGS_TYPE_PLUGINS,
ResourceIdentifier(),
Value::CreateIntegerValue(setting));
}
}
NotifyObservers(primary_pattern,
secondary_pattern,
CONTENT_SETTINGS_TYPE_PLUGINS,
ResourceIdentifier());
}
} // namespace content_settings
|
