src/chrome/browser/plugins/plugin_prefs_unittest.cc

   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
  22 using content::BrowserThread;
  23 using content::PluginService;
  24
  25 namespace {
  26
  27 void 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
  34 base::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
  44 base::FilePath GetBundledPepperFlashPath() {
  45   base::FilePath path;
  46   EXPECT_TRUE(PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN, &path));
  47   return path;
  48 }
  49
  50 void GotPlugins(const base::Closure& quit_closure,
  51                 const std::vector<content::WebPluginInfo>& plugins) {
  52   quit_closure.Run();
  53 }
  54
  55 }  // namespace
  56
  57 class 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
  86 TEST_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
 103 TEST_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
 119 TEST_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
 189 TEST_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