src/chrome/browser/plugins/plugin_info_message_filter_unittest.cc

   1 // Copyright 2014 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_info_message_filter.h"
   6
   7 #include "base/at_exit.h"
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/run_loop.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chrome/common/pref_names.h"
  14 #include "chrome/common/render_messages.h"
  15 #include "chrome/test/base/testing_pref_service_syncable.h"
  16 #include "chrome/test/base/testing_profile.h"
  17 #include "components/content_settings/core/browser/host_content_settings_map.h"
  18 #include "content/public/browser/plugin_service.h"
  19 #include "content/public/browser/plugin_service_filter.h"
  20 #include "content/public/browser/render_process_host.h"
  21 #include "content/public/test/test_browser_thread_bundle.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 using content::PluginService;
  26
  27 namespace {
  28
  29 void PluginsLoaded(const base::Closure& callback,
  30                    const std::vector<content::WebPluginInfo>& plugins) {
  31   callback.Run();
  32 }
  33
  34 class FakePluginServiceFilter : public content::PluginServiceFilter {
  35  public:
  36   FakePluginServiceFilter() {}
  37   ~FakePluginServiceFilter() override {}
  38
  39   bool IsPluginAvailable(int render_process_id,
  40                          int render_view_id,
  41                          const void* context,
  42                          const GURL& url,
  43                          const GURL& policy_url,
  44                          content::WebPluginInfo* plugin) override;
  45
  46   bool CanLoadPlugin(int render_process_id,
  47                      const base::FilePath& path) override;
  48
  49   void set_plugin_enabled(const base::FilePath& plugin_path, bool enabled) {
  50     plugin_state_[plugin_path] = enabled;
  51   }
  52
  53  private:
  54   std::map<base::FilePath, bool> plugin_state_;
  55 };
  56
  57 bool FakePluginServiceFilter::IsPluginAvailable(
  58     int render_process_id,
  59     int render_view_id,
  60     const void* context,
  61     const GURL& url,
  62     const GURL& policy_url,
  63     content::WebPluginInfo* plugin) {
  64   std::map<base::FilePath, bool>::iterator it =
  65       plugin_state_.find(plugin->path);
  66   if (it == plugin_state_.end()) {
  67     ADD_FAILURE() << "No plug-in state for '" << plugin->path.value() << "'";
  68     return false;
  69   }
  70   return it->second;
  71 }
  72
  73 bool FakePluginServiceFilter::CanLoadPlugin(int render_process_id,
  74                                             const base::FilePath& path) {
  75   return true;
  76 }
  77
  78 }  // namespace
  79
  80 class PluginInfoMessageFilterTest : public ::testing::Test {
  81  public:
  82   PluginInfoMessageFilterTest() :
  83       foo_plugin_path_(FILE_PATH_LITERAL("/path/to/foo")),
  84       bar_plugin_path_(FILE_PATH_LITERAL("/path/to/bar")),
  85       context_(0, &profile_) {
  86   }
  87
  88   void SetUp() override {
  89     content::WebPluginInfo foo_plugin(base::ASCIIToUTF16("Foo Plug-in"),
  90                                       foo_plugin_path_,
  91                                       base::ASCIIToUTF16("1"),
  92                                       base::ASCIIToUTF16("The Foo plug-in."));
  93     content::WebPluginMimeType mime_type;
  94     mime_type.mime_type = "foo/bar";
  95     foo_plugin.mime_types.push_back(mime_type);
  96     foo_plugin.type = content::WebPluginInfo::PLUGIN_TYPE_PEPPER_IN_PROCESS;
  97     PluginService::GetInstance()->Init();
  98     PluginService::GetInstance()->RegisterInternalPlugin(foo_plugin, false);
  99
 100     content::WebPluginInfo bar_plugin(base::ASCIIToUTF16("Bar Plug-in"),
 101                                       bar_plugin_path_,
 102                                       base::ASCIIToUTF16("1"),
 103                                       base::ASCIIToUTF16("The Bar plug-in."));
 104     mime_type.mime_type = "foo/bar";
 105     bar_plugin.mime_types.push_back(mime_type);
 106     bar_plugin.type = content::WebPluginInfo::PLUGIN_TYPE_PEPPER_IN_PROCESS;
 107     PluginService::GetInstance()->RegisterInternalPlugin(bar_plugin, false);
 108
 109     PluginService::GetInstance()->SetFilter(&filter_);
 110
 111 #if !defined(OS_WIN)
 112     // Can't go out of process in unit tests.
 113     content::RenderProcessHost::SetRunRendererInProcess(true);
 114 #endif
 115     base::RunLoop run_loop;
 116     PluginService::GetInstance()->GetPlugins(
 117         base::Bind(&PluginsLoaded, run_loop.QuitClosure()));
 118     run_loop.Run();
 119 #if !defined(OS_WIN)
 120     content::RenderProcessHost::SetRunRendererInProcess(false);
 121 #endif
 122   }
 123
 124  protected:
 125   TestingProfile* profile() {
 126     return &profile_;
 127   }
 128
 129   PluginInfoMessageFilter::Context* context() {
 130     return &context_;
 131   }
 132
 133   void VerifyPluginContentSetting(const GURL& url,
 134                                   const std::string& plugin,
 135                                   ContentSetting expected_setting,
 136                                   bool expected_is_default,
 137                                   bool expected_is_managed) {
 138     ContentSetting setting = expected_setting == CONTENT_SETTING_DEFAULT ?
 139         CONTENT_SETTING_BLOCK : CONTENT_SETTING_DEFAULT;
 140     bool is_default = !expected_is_default;
 141     bool is_managed = !expected_is_managed;
 142     context()->GetPluginContentSetting(
 143         content::WebPluginInfo(), url, url, plugin,
 144         &setting, &is_default, &is_managed);
 145     EXPECT_EQ(expected_setting, setting);
 146     EXPECT_EQ(expected_is_default, is_default);
 147     EXPECT_EQ(expected_is_managed, is_managed);
 148   }
 149
 150   base::FilePath foo_plugin_path_;
 151   base::FilePath bar_plugin_path_;
 152   FakePluginServiceFilter filter_;
 153
 154  private:
 155   base::ShadowingAtExitManager at_exit_manager_;  // Destroys the PluginService.
 156   content::TestBrowserThreadBundle test_thread_bundle;
 157   TestingProfile profile_;
 158   PluginInfoMessageFilter::Context context_;
 159 };
 160
 161 TEST_F(PluginInfoMessageFilterTest, FindEnabledPlugin) {
 162   filter_.set_plugin_enabled(foo_plugin_path_, true);
 163   filter_.set_plugin_enabled(bar_plugin_path_, true);
 164   {
 165     ChromeViewHostMsg_GetPluginInfo_Status status;
 166     content::WebPluginInfo plugin;
 167     std::string actual_mime_type;
 168     EXPECT_TRUE(context()->FindEnabledPlugin(
 169         0, GURL(), GURL(), "foo/bar", &status, &plugin, &actual_mime_type,
 170         NULL));
 171     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kAllowed, status.value);
 172     EXPECT_EQ(foo_plugin_path_.value(), plugin.path.value());
 173   }
 174
 175   filter_.set_plugin_enabled(foo_plugin_path_, false);
 176   {
 177     ChromeViewHostMsg_GetPluginInfo_Status status;
 178     content::WebPluginInfo plugin;
 179     std::string actual_mime_type;
 180     EXPECT_TRUE(context()->FindEnabledPlugin(
 181         0, GURL(), GURL(), "foo/bar", &status, &plugin, &actual_mime_type,
 182         NULL));
 183     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kAllowed, status.value);
 184     EXPECT_EQ(bar_plugin_path_.value(), plugin.path.value());
 185   }
 186
 187   filter_.set_plugin_enabled(bar_plugin_path_, false);
 188   {
 189     ChromeViewHostMsg_GetPluginInfo_Status status;
 190     content::WebPluginInfo plugin;
 191     std::string actual_mime_type;
 192     std::string identifier;
 193     base::string16 plugin_name;
 194     EXPECT_FALSE(context()->FindEnabledPlugin(
 195         0, GURL(), GURL(), "foo/bar", &status, &plugin, &actual_mime_type,
 196         NULL));
 197     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kDisabled, status.value);
 198     EXPECT_EQ(foo_plugin_path_.value(), plugin.path.value());
 199   }
 200   {
 201     ChromeViewHostMsg_GetPluginInfo_Status status;
 202     content::WebPluginInfo plugin;
 203     std::string actual_mime_type;
 204     EXPECT_FALSE(context()->FindEnabledPlugin(
 205         0, GURL(), GURL(), "baz/blurp", &status, &plugin, &actual_mime_type,
 206         NULL));
 207     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kNotFound, status.value);
 208     EXPECT_EQ(FILE_PATH_LITERAL(""), plugin.path.value());
 209   }
 210 }
 211
 212 TEST_F(PluginInfoMessageFilterTest, GetPluginContentSetting) {
 213   HostContentSettingsMap* map = profile()->GetHostContentSettingsMap();
 214
 215   // Block plugins by default.
 216   map->SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_PLUGINS,
 217                                 CONTENT_SETTING_BLOCK);
 218
 219   // Set plugins to click-to-play on example.com and subdomains.
 220   ContentSettingsPattern pattern =
 221        ContentSettingsPattern::FromString("[*.]example.com");
 222   map->SetContentSetting(pattern,
 223                          ContentSettingsPattern::Wildcard(),
 224                          CONTENT_SETTINGS_TYPE_PLUGINS,
 225                          std::string(),
 226                          CONTENT_SETTING_ASK);
 227
 228   // Allow plugin "foo" on all sites.
 229   map->SetContentSetting(ContentSettingsPattern::Wildcard(),
 230                          ContentSettingsPattern::Wildcard(),
 231                          CONTENT_SETTINGS_TYPE_PLUGINS,
 232                          "foo",
 233                          CONTENT_SETTING_ALLOW);
 234
 235   GURL unmatched_host("https://www.google.com");
 236   GURL host("http://example.com/");
 237   ASSERT_EQ(CONTENT_SETTING_BLOCK, map->GetContentSetting(
 238       unmatched_host, unmatched_host, CONTENT_SETTINGS_TYPE_PLUGINS,
 239       std::string()));
 240   ASSERT_EQ(CONTENT_SETTING_ASK, map->GetContentSetting(
 241       host, host, CONTENT_SETTINGS_TYPE_PLUGINS, std::string()));
 242   ASSERT_EQ(CONTENT_SETTING_ALLOW, map->GetContentSetting(
 243       host, host, CONTENT_SETTINGS_TYPE_PLUGINS, "foo"));
 244   ASSERT_EQ(CONTENT_SETTING_DEFAULT, map->GetContentSetting(
 245       host, host, CONTENT_SETTINGS_TYPE_PLUGINS, "bar"));
 246
 247   // "foo" is allowed everywhere.
 248   VerifyPluginContentSetting(host, "foo", CONTENT_SETTING_ALLOW, false, false);
 249
 250   // There is no specific content setting for "bar", so the general setting
 251   // for example.com applies.
 252   VerifyPluginContentSetting(host, "bar", CONTENT_SETTING_ASK, false, false);
 253
 254   // Otherwise, use the default.
 255   VerifyPluginContentSetting(unmatched_host, "bar", CONTENT_SETTING_BLOCK,
 256                              true, false);
 257
 258   // Block plugins via policy.
 259   TestingPrefServiceSyncable* prefs = profile()->GetTestingPrefService();
 260   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
 261                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 262
 263   // All plugins should be blocked now.
 264   VerifyPluginContentSetting(host, "foo", CONTENT_SETTING_BLOCK, true, true);
 265   VerifyPluginContentSetting(host, "bar", CONTENT_SETTING_BLOCK, true, true);
 266   VerifyPluginContentSetting(unmatched_host, "bar", CONTENT_SETTING_BLOCK,
 267                              true, true);
 268 }