plugin_prefs_unittest.cc revision ca12bfac764ba476d6cd062bf1dde12cc64c3f40 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/plugins/plugin_prefs.h"
6
7#include "base/at_exit.h"
8#include "base/bind.h"
9#include "base/message_loop/message_loop.h"
10#include "base/path_service.h"
11#include "base/run_loop.h"
12#include "base/strings/utf_string_conversions.h"
13#include "chrome/common/chrome_constants.h"
14#include "chrome/common/chrome_paths.h"
15#include "content/public/browser/plugin_service.h"
16#include "content/public/browser/render_process_host.h"
17#include "content/public/common/webplugininfo.h"
18#include "content/public/test/test_browser_thread.h"
19#include "content/public/test/test_utils.h"
20#include "testing/gtest/include/gtest/gtest.h"
21
22using content::BrowserThread;
23using content::PluginService;
24
25namespace {
26
27void CanEnablePluginCallback(const base::Closure& quit_closure,
28                             bool expected_can_change,
29                             bool did_change) {
30  EXPECT_EQ(expected_can_change, did_change);
31  quit_closure.Run();
32}
33
34base::FilePath GetComponentUpdatedPepperFlashPath(
35    const base::FilePath::StringType& version) {
36  base::FilePath path;
37  EXPECT_TRUE(PathService::Get(
38      chrome::DIR_COMPONENT_UPDATED_PEPPER_FLASH_PLUGIN, &path));
39  path = path.Append(version);
40  path = path.Append(chrome::kPepperFlashPluginFilename);
41  return path;
42}
43
44base::FilePath GetBundledPepperFlashPath() {
45  base::FilePath path;
46  EXPECT_TRUE(PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN, &path));
47  return path;
48}
49
50void GotPlugins(const base::Closure& quit_closure,
51                const std::vector<content::WebPluginInfo>& plugins) {
52  quit_closure.Run();
53}
54
55}  // namespace
56
57class PluginPrefsTest : public ::testing::Test {
58 public:
59  virtual void SetUp() OVERRIDE {
60    plugin_prefs_ = new PluginPrefs();
61  }
62
63  void SetPolicyEnforcedPluginPatterns(
64      const std::set<string16>& disabled,
65      const std::set<string16>& disabled_exceptions,
66      const std::set<string16>& enabled) {
67    plugin_prefs_->SetPolicyEnforcedPluginPatterns(
68        disabled, disabled_exceptions, enabled);
69  }
70
71 protected:
72  void EnablePluginSynchronously(bool enabled,
73                                 const base::FilePath& path,
74                                 bool expected_can_change) {
75    base::RunLoop run_loop;
76    plugin_prefs_->EnablePlugin(
77        enabled, path,
78        base::Bind(&CanEnablePluginCallback, run_loop.QuitClosure(),
79                   expected_can_change));
80    run_loop.Run();
81  }
82
83  scoped_refptr<PluginPrefs> plugin_prefs_;
84};
85
86TEST_F(PluginPrefsTest, DisabledByPolicy) {
87  std::set<string16> disabled_plugins;
88  disabled_plugins.insert(ASCIIToUTF16("Disable this!"));
89  disabled_plugins.insert(ASCIIToUTF16("*Google*"));
90  SetPolicyEnforcedPluginPatterns(disabled_plugins,
91                                  std::set<string16>(),
92                                  std::set<string16>());
93
94  EXPECT_EQ(PluginPrefs::NO_POLICY,
95            plugin_prefs_->PolicyStatusForPlugin(ASCIIToUTF16("42")));
96  EXPECT_EQ(PluginPrefs::POLICY_DISABLED,
97            plugin_prefs_->PolicyStatusForPlugin(
98                ASCIIToUTF16("Disable this!")));
99  EXPECT_EQ(PluginPrefs::POLICY_DISABLED,
100            plugin_prefs_->PolicyStatusForPlugin(ASCIIToUTF16("Google Earth")));
101}
102
103TEST_F(PluginPrefsTest, EnabledByPolicy) {
104  std::set<string16> enabled_plugins;
105  enabled_plugins.insert(ASCIIToUTF16("Enable that!"));
106  enabled_plugins.insert(ASCIIToUTF16("PDF*"));
107  SetPolicyEnforcedPluginPatterns(std::set<string16>(),
108                                  std::set<string16>(),
109                                  enabled_plugins);
110
111  EXPECT_EQ(PluginPrefs::NO_POLICY,
112            plugin_prefs_->PolicyStatusForPlugin(ASCIIToUTF16("42")));
113  EXPECT_EQ(PluginPrefs::POLICY_ENABLED,
114            plugin_prefs_->PolicyStatusForPlugin(ASCIIToUTF16("Enable that!")));
115  EXPECT_EQ(PluginPrefs::POLICY_ENABLED,
116            plugin_prefs_->PolicyStatusForPlugin(ASCIIToUTF16("PDF Reader")));
117}
118
119TEST_F(PluginPrefsTest, EnabledAndDisabledByPolicy) {
120  const string16 k42(ASCIIToUTF16("42"));
121  const string16 kEnabled(ASCIIToUTF16("Enabled"));
122  const string16 kEnabled2(ASCIIToUTF16("Enabled 2"));
123  const string16 kEnabled3(ASCIIToUTF16("Enabled 3"));
124  const string16 kException(ASCIIToUTF16("Exception"));
125  const string16 kException2(ASCIIToUTF16("Exception 2"));
126  const string16 kGoogleMars(ASCIIToUTF16("Google Mars"));
127  const string16 kGoogleEarth(ASCIIToUTF16("Google Earth"));
128
129  std::set<string16> disabled_plugins;
130  std::set<string16> disabled_plugins_exceptions;
131  std::set<string16> enabled_plugins;
132
133  disabled_plugins.insert(kEnabled);
134  disabled_plugins_exceptions.insert(kEnabled);
135  enabled_plugins.insert(kEnabled);
136
137  disabled_plugins_exceptions.insert(kException);
138
139  disabled_plugins.insert(kEnabled2);
140  enabled_plugins.insert(kEnabled2);
141
142  disabled_plugins.insert(kException2);
143  disabled_plugins_exceptions.insert(kException2);
144
145  disabled_plugins_exceptions.insert(kEnabled3);
146  enabled_plugins.insert(kEnabled3);
147
148  SetPolicyEnforcedPluginPatterns(disabled_plugins,
149                                  disabled_plugins_exceptions,
150                                  enabled_plugins);
151
152  EXPECT_EQ(PluginPrefs::NO_POLICY, plugin_prefs_->PolicyStatusForPlugin(k42));
153
154  EXPECT_EQ(PluginPrefs::POLICY_ENABLED,
155            plugin_prefs_->PolicyStatusForPlugin(kEnabled));
156  EXPECT_EQ(PluginPrefs::POLICY_ENABLED,
157            plugin_prefs_->PolicyStatusForPlugin(kEnabled2));
158  EXPECT_EQ(PluginPrefs::POLICY_ENABLED,
159            plugin_prefs_->PolicyStatusForPlugin(kEnabled3));
160
161  EXPECT_EQ(PluginPrefs::NO_POLICY,
162            plugin_prefs_->PolicyStatusForPlugin(kException));
163  EXPECT_EQ(PluginPrefs::NO_POLICY,
164            plugin_prefs_->PolicyStatusForPlugin(kException2));
165
166  disabled_plugins.clear();
167  disabled_plugins_exceptions.clear();
168  enabled_plugins.clear();
169
170  disabled_plugins.insert(ASCIIToUTF16("*"));
171  disabled_plugins_exceptions.insert(ASCIIToUTF16("*Google*"));
172  enabled_plugins.insert(kGoogleEarth);
173
174  SetPolicyEnforcedPluginPatterns(disabled_plugins,
175                                  disabled_plugins_exceptions,
176                                  enabled_plugins);
177
178  EXPECT_EQ(PluginPrefs::POLICY_ENABLED,
179            plugin_prefs_->PolicyStatusForPlugin(kGoogleEarth));
180  EXPECT_EQ(PluginPrefs::NO_POLICY,
181            plugin_prefs_->PolicyStatusForPlugin(kGoogleMars));
182  EXPECT_EQ(PluginPrefs::POLICY_DISABLED,
183            plugin_prefs_->PolicyStatusForPlugin(k42));
184}
185
186// Linux Aura doesn't support NPAPI.
187#if !(defined(OS_LINUX) && defined(USE_AURA))
188
189TEST_F(PluginPrefsTest, UnifiedPepperFlashState) {
190  base::ShadowingAtExitManager at_exit_manager_;  // Destroys the PluginService.
191
192  base::MessageLoop message_loop;
193  content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
194  PluginService::GetInstance()->Init();
195  PluginService::GetInstance()->DisablePluginsDiscoveryForTesting();
196
197  string16 component_updated_plugin_name(
198      ASCIIToUTF16("Component-updated Pepper Flash"));
199  content::WebPluginInfo component_updated_plugin_1(
200      component_updated_plugin_name,
201      GetComponentUpdatedPepperFlashPath(FILE_PATH_LITERAL("11.3.31.227")),
202      ASCIIToUTF16("11.3.31.227"),
203      ASCIIToUTF16(""));
204  content::WebPluginInfo component_updated_plugin_2(
205      component_updated_plugin_name,
206      GetComponentUpdatedPepperFlashPath(FILE_PATH_LITERAL("11.3.31.228")),
207      ASCIIToUTF16("11.3.31.228"),
208      ASCIIToUTF16(""));
209  content::WebPluginInfo bundled_plugin(ASCIIToUTF16("Pepper Flash"),
210                                        GetBundledPepperFlashPath(),
211                                        ASCIIToUTF16("11.3.31.229"),
212                                        ASCIIToUTF16(""));
213
214  PluginService::GetInstance()->RegisterInternalPlugin(
215      component_updated_plugin_1, false);
216  PluginService::GetInstance()->RegisterInternalPlugin(
217      component_updated_plugin_2, false);
218  PluginService::GetInstance()->RegisterInternalPlugin(bundled_plugin, false);
219
220#if !defined(OS_WIN)
221    // Can't go out of process in unit tests.
222    content::RenderProcessHost::SetRunRendererInProcess(true);
223#endif
224  scoped_refptr<content::MessageLoopRunner> runner =
225      new content::MessageLoopRunner;
226  PluginService::GetInstance()->GetPlugins(
227      base::Bind(&GotPlugins, runner->QuitClosure()));
228  runner->Run();
229#if !defined(OS_WIN)
230    content::RenderProcessHost::SetRunRendererInProcess(false);
231#endif
232
233  // Set the state of any of the three plugins will affect the others.
234  EnablePluginSynchronously(true, component_updated_plugin_1.path, true);
235  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_1));
236  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_2));
237  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(bundled_plugin));
238
239  EnablePluginSynchronously(false, bundled_plugin.path, true);
240  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_1));
241  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_2));
242  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(bundled_plugin));
243
244  EnablePluginSynchronously(true, component_updated_plugin_2.path, true);
245  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_1));
246  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_2));
247  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(bundled_plugin));
248
249  std::set<string16> disabled_plugins;
250  disabled_plugins.insert(component_updated_plugin_name);
251  SetPolicyEnforcedPluginPatterns(disabled_plugins,
252                                  std::set<string16>(),
253                                  std::set<string16>());
254
255  // Policy settings should be respected.
256  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_1));
257  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_2));
258  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(bundled_plugin));
259
260  EnablePluginSynchronously(false, bundled_plugin.path, true);
261  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(bundled_plugin));
262
263  // Trying to change the state of a policy-enforced plugin should not take
264  // effect. And it shouldn't change the state of other plugins either, even if
265  // they are not restricted by any policy.
266  EnablePluginSynchronously(true, component_updated_plugin_1.path, false);
267  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_1));
268  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_2));
269  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(bundled_plugin));
270
271  EnablePluginSynchronously(true, bundled_plugin.path, true);
272  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_1));
273  EXPECT_FALSE(plugin_prefs_->IsPluginEnabled(component_updated_plugin_2));
274  EXPECT_TRUE(plugin_prefs_->IsPluginEnabled(bundled_plugin));
275}
276
277#endif
278