content/browser/plugin_loader_posix_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/browser/plugin_loader_posix.h"
   6
   7 #include "base/at_exit.h"
   8 #include "base/bind.h"
   9 #include "base/files/file_path.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "content/browser/browser_thread_impl.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 using base::ASCIIToUTF16;
  18
  19 namespace content {
  20
  21 class MockPluginLoaderPosix : public PluginLoaderPosix {
  22  public:
  23   MOCK_METHOD0(LoadPluginsInternal, void(void));
  24
  25   size_t number_of_pending_callbacks() {
  26     return callbacks_.size();
  27   }
  28
  29   std::vector<base::FilePath>* canonical_list() {
  30     return &canonical_list_;
  31   }
  32
  33   size_t next_load_index() {
  34     return next_load_index_;
  35   }
  36
  37   const std::vector<WebPluginInfo>& loaded_plugins() {
  38     return loaded_plugins_;
  39   }
  40
  41   std::vector<WebPluginInfo>* internal_plugins() {
  42     return &internal_plugins_;
  43   }
  44
  45   void RealLoadPluginsInternal() {
  46     PluginLoaderPosix::LoadPluginsInternal();
  47   }
  48
  49   void TestOnPluginLoaded(uint32 index, const WebPluginInfo& plugin) {
  50     OnPluginLoaded(index, plugin);
  51   }
  52
  53   void TestOnPluginLoadFailed(uint32 index, const base::FilePath& path) {
  54     OnPluginLoadFailed(index, path);
  55   }
  56
  57  protected:
  58   virtual ~MockPluginLoaderPosix() {}
  59 };
  60
  61 void VerifyCallback(int* run_count, const std::vector<WebPluginInfo>&) {
  62   ++(*run_count);
  63 }
  64
  65 class PluginLoaderPosixTest : public testing::Test {
  66  public:
  67   PluginLoaderPosixTest()
  68       : plugin1_(ASCIIToUTF16("plugin1"), base::FilePath("/tmp/one.plugin"),
  69                  ASCIIToUTF16("1.0"), base::string16()),
  70         plugin2_(ASCIIToUTF16("plugin2"), base::FilePath("/tmp/two.plugin"),
  71                  ASCIIToUTF16("2.0"), base::string16()),
  72         plugin3_(ASCIIToUTF16("plugin3"), base::FilePath("/tmp/three.plugin"),
  73                  ASCIIToUTF16("3.0"), base::string16()),
  74         file_thread_(BrowserThread::FILE, &message_loop_),
  75         io_thread_(BrowserThread::IO, &message_loop_),
  76         plugin_loader_(new MockPluginLoaderPosix) {
  77   }
  78
  79   virtual void SetUp() OVERRIDE {
  80     PluginServiceImpl::GetInstance()->Init();
  81   }
  82
  83   base::MessageLoop* message_loop() { return &message_loop_; }
  84   MockPluginLoaderPosix* plugin_loader() { return plugin_loader_.get(); }
  85
  86   void AddThreePlugins() {
  87     plugin_loader_->canonical_list()->clear();
  88     plugin_loader_->canonical_list()->push_back(plugin1_.path);
  89     plugin_loader_->canonical_list()->push_back(plugin2_.path);
  90     plugin_loader_->canonical_list()->push_back(plugin3_.path);
  91   }
  92
  93   // Data used for testing.
  94   WebPluginInfo plugin1_;
  95   WebPluginInfo plugin2_;
  96   WebPluginInfo plugin3_;
  97
  98  private:
  99   base::ShadowingAtExitManager at_exit_manager_;  // Destroys PluginService.
 100
 101   base::MessageLoopForIO message_loop_;
 102   BrowserThreadImpl file_thread_;
 103   BrowserThreadImpl io_thread_;
 104
 105   scoped_refptr<MockPluginLoaderPosix> plugin_loader_;
 106 };
 107
 108 TEST_F(PluginLoaderPosixTest, QueueRequests) {
 109   int did_callback = 0;
 110   PluginService::GetPluginsCallback callback =
 111       base::Bind(&VerifyCallback, base::Unretained(&did_callback));
 112
 113   EXPECT_EQ(0u, plugin_loader()->number_of_pending_callbacks());
 114   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 115   EXPECT_EQ(1u, plugin_loader()->number_of_pending_callbacks());
 116
 117   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 118   EXPECT_EQ(2u, plugin_loader()->number_of_pending_callbacks());
 119
 120   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(2);
 121   message_loop()->RunUntilIdle();
 122
 123   EXPECT_EQ(0, did_callback);
 124
 125   plugin_loader()->canonical_list()->clear();
 126   plugin_loader()->canonical_list()->push_back(plugin1_.path);
 127   plugin_loader()->TestOnPluginLoaded(0, plugin1_);
 128   message_loop()->RunUntilIdle();
 129
 130   EXPECT_EQ(1, did_callback);
 131   EXPECT_EQ(1u, plugin_loader()->number_of_pending_callbacks());
 132
 133   plugin_loader()->canonical_list()->clear();
 134   plugin_loader()->canonical_list()->push_back(plugin1_.path);
 135   plugin_loader()->TestOnPluginLoaded(0, plugin1_);
 136   message_loop()->RunUntilIdle();
 137
 138   EXPECT_EQ(2, did_callback);
 139   EXPECT_EQ(0u, plugin_loader()->number_of_pending_callbacks());
 140 }
 141
 142 TEST_F(PluginLoaderPosixTest, ThreeSuccessfulLoads) {
 143   int did_callback = 0;
 144   PluginService::GetPluginsCallback callback =
 145       base::Bind(&VerifyCallback, base::Unretained(&did_callback));
 146
 147   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 148
 149   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(1);
 150   message_loop()->RunUntilIdle();
 151
 152   AddThreePlugins();
 153
 154   EXPECT_EQ(0u, plugin_loader()->next_load_index());
 155
 156   const std::vector<WebPluginInfo>& plugins(plugin_loader()->loaded_plugins());
 157
 158   plugin_loader()->TestOnPluginLoaded(0, plugin1_);
 159   EXPECT_EQ(1u, plugin_loader()->next_load_index());
 160   EXPECT_EQ(1u, plugins.size());
 161   EXPECT_EQ(plugin1_.name, plugins[0].name);
 162
 163   message_loop()->RunUntilIdle();
 164   EXPECT_EQ(0, did_callback);
 165
 166   plugin_loader()->TestOnPluginLoaded(1, plugin2_);
 167   EXPECT_EQ(2u, plugin_loader()->next_load_index());
 168   EXPECT_EQ(2u, plugins.size());
 169   EXPECT_EQ(plugin2_.name, plugins[1].name);
 170
 171   message_loop()->RunUntilIdle();
 172   EXPECT_EQ(0, did_callback);
 173
 174   plugin_loader()->TestOnPluginLoaded(2, plugin3_);
 175   EXPECT_EQ(3u, plugins.size());
 176   EXPECT_EQ(plugin3_.name, plugins[2].name);
 177
 178   message_loop()->RunUntilIdle();
 179   EXPECT_EQ(1, did_callback);
 180 }
 181
 182 TEST_F(PluginLoaderPosixTest, ThreeSuccessfulLoadsThenCrash) {
 183   int did_callback = 0;
 184   PluginService::GetPluginsCallback callback =
 185       base::Bind(&VerifyCallback, base::Unretained(&did_callback));
 186
 187   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 188
 189   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(2);
 190   message_loop()->RunUntilIdle();
 191
 192   AddThreePlugins();
 193
 194   EXPECT_EQ(0u, plugin_loader()->next_load_index());
 195
 196   const std::vector<WebPluginInfo>& plugins(plugin_loader()->loaded_plugins());
 197
 198   plugin_loader()->TestOnPluginLoaded(0, plugin1_);
 199   EXPECT_EQ(1u, plugin_loader()->next_load_index());
 200   EXPECT_EQ(1u, plugins.size());
 201   EXPECT_EQ(plugin1_.name, plugins[0].name);
 202
 203   message_loop()->RunUntilIdle();
 204   EXPECT_EQ(0, did_callback);
 205
 206   plugin_loader()->TestOnPluginLoaded(1, plugin2_);
 207   EXPECT_EQ(2u, plugin_loader()->next_load_index());
 208   EXPECT_EQ(2u, plugins.size());
 209   EXPECT_EQ(plugin2_.name, plugins[1].name);
 210
 211   message_loop()->RunUntilIdle();
 212   EXPECT_EQ(0, did_callback);
 213
 214   plugin_loader()->TestOnPluginLoaded(2, plugin3_);
 215   EXPECT_EQ(3u, plugins.size());
 216   EXPECT_EQ(plugin3_.name, plugins[2].name);
 217
 218   message_loop()->RunUntilIdle();
 219   EXPECT_EQ(1, did_callback);
 220
 221   plugin_loader()->OnProcessCrashed(42);
 222 }
 223
 224 TEST_F(PluginLoaderPosixTest, TwoFailures) {
 225   int did_callback = 0;
 226   PluginService::GetPluginsCallback callback =
 227       base::Bind(&VerifyCallback, base::Unretained(&did_callback));
 228
 229   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 230
 231   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(1);
 232   message_loop()->RunUntilIdle();
 233
 234   AddThreePlugins();
 235
 236   EXPECT_EQ(0u, plugin_loader()->next_load_index());
 237
 238   const std::vector<WebPluginInfo>& plugins(plugin_loader()->loaded_plugins());
 239
 240   plugin_loader()->TestOnPluginLoadFailed(0, plugin1_.path);
 241   EXPECT_EQ(1u, plugin_loader()->next_load_index());
 242   EXPECT_EQ(0u, plugins.size());
 243
 244   message_loop()->RunUntilIdle();
 245   EXPECT_EQ(0, did_callback);
 246
 247   plugin_loader()->TestOnPluginLoaded(1, plugin2_);
 248   EXPECT_EQ(2u, plugin_loader()->next_load_index());
 249   EXPECT_EQ(1u, plugins.size());
 250   EXPECT_EQ(plugin2_.name, plugins[0].name);
 251
 252   message_loop()->RunUntilIdle();
 253   EXPECT_EQ(0, did_callback);
 254
 255   plugin_loader()->TestOnPluginLoadFailed(2, plugin3_.path);
 256   EXPECT_EQ(1u, plugins.size());
 257
 258   message_loop()->RunUntilIdle();
 259   EXPECT_EQ(1, did_callback);
 260 }
 261
 262 TEST_F(PluginLoaderPosixTest, CrashedProcess) {
 263   int did_callback = 0;
 264   PluginService::GetPluginsCallback callback =
 265       base::Bind(&VerifyCallback, base::Unretained(&did_callback));
 266
 267   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 268
 269   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(1);
 270   message_loop()->RunUntilIdle();
 271
 272   AddThreePlugins();
 273
 274   EXPECT_EQ(0u, plugin_loader()->next_load_index());
 275
 276   const std::vector<WebPluginInfo>& plugins(plugin_loader()->loaded_plugins());
 277
 278   plugin_loader()->TestOnPluginLoaded(0, plugin1_);
 279   EXPECT_EQ(1u, plugin_loader()->next_load_index());
 280   EXPECT_EQ(1u, plugins.size());
 281   EXPECT_EQ(plugin1_.name, plugins[0].name);
 282
 283   message_loop()->RunUntilIdle();
 284   EXPECT_EQ(0, did_callback);
 285
 286   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(1);
 287   plugin_loader()->OnProcessCrashed(42);
 288   EXPECT_EQ(1u, plugin_loader()->canonical_list()->size());
 289   EXPECT_EQ(0u, plugin_loader()->next_load_index());
 290   EXPECT_EQ(plugin3_.path.value(),
 291             plugin_loader()->canonical_list()->at(0).value());
 292 }
 293
 294 TEST_F(PluginLoaderPosixTest, InternalPlugin) {
 295   int did_callback = 0;
 296   PluginService::GetPluginsCallback callback =
 297       base::Bind(&VerifyCallback, base::Unretained(&did_callback));
 298
 299   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 300
 301   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(1);
 302   message_loop()->RunUntilIdle();
 303
 304   plugin2_.path = base::FilePath("/internal/plugin.plugin");
 305
 306   AddThreePlugins();
 307
 308   plugin_loader()->internal_plugins()->clear();
 309   plugin_loader()->internal_plugins()->push_back(plugin2_);
 310
 311   EXPECT_EQ(0u, plugin_loader()->next_load_index());
 312
 313   const std::vector<WebPluginInfo>& plugins(plugin_loader()->loaded_plugins());
 314
 315   plugin_loader()->TestOnPluginLoaded(0, plugin1_);
 316   EXPECT_EQ(1u, plugin_loader()->next_load_index());
 317   EXPECT_EQ(1u, plugins.size());
 318   EXPECT_EQ(plugin1_.name, plugins[0].name);
 319
 320   message_loop()->RunUntilIdle();
 321   EXPECT_EQ(0, did_callback);
 322
 323   // Internal plugins can fail to load if they're built-in with manual
 324   // entrypoint functions.
 325   plugin_loader()->TestOnPluginLoadFailed(1, plugin2_.path);
 326   EXPECT_EQ(2u, plugin_loader()->next_load_index());
 327   EXPECT_EQ(2u, plugins.size());
 328   EXPECT_EQ(plugin2_.name, plugins[1].name);
 329   EXPECT_EQ(0u, plugin_loader()->internal_plugins()->size());
 330
 331   message_loop()->RunUntilIdle();
 332   EXPECT_EQ(0, did_callback);
 333
 334   plugin_loader()->TestOnPluginLoaded(2, plugin3_);
 335   EXPECT_EQ(3u, plugins.size());
 336   EXPECT_EQ(plugin3_.name, plugins[2].name);
 337
 338   message_loop()->RunUntilIdle();
 339   EXPECT_EQ(1, did_callback);
 340 }
 341
 342 TEST_F(PluginLoaderPosixTest, AllCrashed) {
 343   int did_callback = 0;
 344   PluginService::GetPluginsCallback callback =
 345       base::Bind(&VerifyCallback, base::Unretained(&did_callback));
 346
 347   plugin_loader()->LoadPlugins(message_loop()->message_loop_proxy(), callback);
 348
 349   // Spin the loop so that the canonical list of plugins can be set.
 350   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(1);
 351   message_loop()->RunUntilIdle();
 352   AddThreePlugins();
 353
 354   EXPECT_EQ(0u, plugin_loader()->next_load_index());
 355
 356   // Mock the first two calls like normal.
 357   testing::Expectation first =
 358       EXPECT_CALL(*plugin_loader(), LoadPluginsInternal()).Times(2);
 359   // On the last call, go through the default impl.
 360   EXPECT_CALL(*plugin_loader(), LoadPluginsInternal())
 361       .After(first)
 362       .WillOnce(
 363           testing::Invoke(plugin_loader(),
 364                           &MockPluginLoaderPosix::RealLoadPluginsInternal));
 365   plugin_loader()->OnProcessCrashed(42);
 366   plugin_loader()->OnProcessCrashed(42);
 367   plugin_loader()->OnProcessCrashed(42);
 368
 369   message_loop()->RunUntilIdle();
 370   EXPECT_EQ(1, did_callback);
 371
 372   EXPECT_EQ(0u, plugin_loader()->loaded_plugins().size());
 373 }
 374
 375 }  // namespace content