content/common/plugin_list_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 "content/common/plugin_list.h"
   6
   7 #include "base/strings/string16.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "url/gurl.h"
  11
  12 namespace content {
  13
  14 namespace {
  15
  16 base::FilePath::CharType kFooPath[] = FILE_PATH_LITERAL("/plugins/foo.plugin");
  17 base::FilePath::CharType kBarPath[] = FILE_PATH_LITERAL("/plugins/bar.plugin");
  18 const char* kFooName = "Foo Plugin";
  19 const char* kFooMimeType = "application/x-foo-mime-type";
  20 const char* kFooFileType = "foo";
  21
  22 bool Equals(const WebPluginInfo& a, const WebPluginInfo& b) {
  23   return (a.name == b.name &&
  24           a.path == b.path &&
  25           a.version == b.version &&
  26           a.desc == b.desc);
  27 }
  28
  29 bool Contains(const std::vector<WebPluginInfo>& list,
  30               const WebPluginInfo& plugin) {
  31   for (std::vector<WebPluginInfo>::const_iterator it = list.begin();
  32        it != list.end(); ++it) {
  33     if (Equals(*it, plugin))
  34       return true;
  35   }
  36   return false;
  37 }
  38
  39 }  // namespace
  40
  41 class PluginListTest : public testing::Test {
  42  public:
  43   PluginListTest()
  44       : foo_plugin_(base::ASCIIToUTF16(kFooName),
  45                     base::FilePath(kFooPath),
  46                     base::ASCIIToUTF16("1.2.3"),
  47                     base::ASCIIToUTF16("foo")),
  48         bar_plugin_(base::ASCIIToUTF16("Bar Plugin"),
  49                     base::FilePath(kBarPath),
  50                     base::ASCIIToUTF16("2.3.4"),
  51                     base::ASCIIToUTF16("bar")) {
  52   }
  53
  54   virtual void SetUp() {
  55     plugin_list_.DisablePluginsDiscovery();
  56     plugin_list_.RegisterInternalPlugin(bar_plugin_, false);
  57     foo_plugin_.mime_types.push_back(
  58         WebPluginMimeType(kFooMimeType, kFooFileType, std::string()));
  59     plugin_list_.RegisterInternalPlugin(foo_plugin_, false);
  60   }
  61
  62  protected:
  63   PluginList plugin_list_;
  64   WebPluginInfo foo_plugin_;
  65   WebPluginInfo bar_plugin_;
  66 };
  67
  68 TEST_F(PluginListTest, GetPlugins) {
  69   std::vector<WebPluginInfo> plugins;
  70   plugin_list_.GetPlugins(&plugins, true);
  71   EXPECT_EQ(2u, plugins.size());
  72   EXPECT_TRUE(Contains(plugins, foo_plugin_));
  73   EXPECT_TRUE(Contains(plugins, bar_plugin_));
  74 }
  75
  76 TEST_F(PluginListTest, BadPluginDescription) {
  77   WebPluginInfo plugin_3043(
  78       base::string16(), base::FilePath(FILE_PATH_LITERAL("/myplugin.3.0.43")),
  79       base::string16(), base::string16());
  80   // Simulate loading of the plugins.
  81   plugin_list_.RegisterInternalPlugin(plugin_3043, false);
  82   // Now we should have them in the state we specified above.
  83   plugin_list_.RefreshPlugins();
  84   std::vector<WebPluginInfo> plugins;
  85   plugin_list_.GetPlugins(&plugins, true);
  86   ASSERT_TRUE(Contains(plugins, plugin_3043));
  87 }
  88
  89 TEST_F(PluginListTest, GetPluginInfoArray) {
  90   const char kTargetUrl[] = "http://example.com/test.foo";
  91   GURL target_url(kTargetUrl);
  92   std::vector<WebPluginInfo> plugins;
  93   std::vector<std::string> actual_mime_types;
  94
  95   // The file type of the URL is supported by foo_plugin_. However,
  96   // GetPluginInfoArray should not match foo_plugin_ because the MIME type is
  97   // application/octet-stream.
  98   plugin_list_.GetPluginInfoArray(target_url,
  99                                   "application/octet-stream",
 100                                   false, // allow_wildcard
 101                                   NULL,  // use_stale
 102                                   false, // include_npapi
 103                                   &plugins,
 104                                   &actual_mime_types);
 105   EXPECT_EQ(0u, plugins.size());
 106   EXPECT_EQ(0u, actual_mime_types.size());
 107
 108   // foo_plugin_ matches due to the MIME type.
 109   plugins.clear();
 110   actual_mime_types.clear();
 111   plugin_list_.GetPluginInfoArray(target_url,
 112                                   kFooMimeType,
 113                                   false, // allow_wildcard
 114                                   NULL,  // use_stale
 115                                   false, // include_npapi
 116                                   &plugins,
 117                                   &actual_mime_types);
 118   EXPECT_EQ(1u, plugins.size());
 119   EXPECT_TRUE(Contains(plugins, foo_plugin_));
 120   ASSERT_EQ(1u, actual_mime_types.size());
 121   EXPECT_EQ(kFooMimeType, actual_mime_types.front());
 122
 123   // foo_plugin_ matches due to the file type and empty MIME type.
 124   plugins.clear();
 125   actual_mime_types.clear();
 126   plugin_list_.GetPluginInfoArray(target_url,
 127                                   "",
 128                                   false, // allow_wildcard
 129                                   NULL,  // use_stale
 130                                   false, // include_npapi
 131                                   &plugins,
 132                                   &actual_mime_types);
 133   EXPECT_EQ(1u, plugins.size());
 134   EXPECT_TRUE(Contains(plugins, foo_plugin_));
 135   ASSERT_EQ(1u, actual_mime_types.size());
 136   EXPECT_EQ(kFooMimeType, actual_mime_types.front());
 137 }
 138
 139 }  // namespace content