Restart plugin loading only if the plugin list has actually become stale.

content/browser/plugin_loader_posix.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/plugin_loader_posix.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "content/browser/utility_process_host_impl.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/plugin_list.h"
 #include "content/common/utility_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/plugin_service.h"
 
 namespace content {
 
 PluginLoaderPosix::PluginLoaderPosix()
     : next_load_index_(0) {
 }
 
-void PluginLoaderPosix::LoadPlugins(
-    scoped_refptr<base::MessageLoopProxy> target_loop,
+void PluginLoaderPosix::GetPlugins(
     const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  callbacks_.push_back(PendingCallback(target_loop, callback));
+  std::vector<WebPluginInfo> cached_plugins;
+  if (PluginList::Singleton()->GetPluginsNoRefresh(&cached_plugins)) {
+    // Can't assume the caller is reentrant.
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(callback, cached_plugins));
+    return;
+  }
 
-  if (callbacks_.size() == 1) {
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-        base::Bind(&PluginLoaderPosix::GetPluginsToLoad, this));
+  if (callbacks_.empty()) {
+    callbacks_.push_back(callback);
+
+    PluginList::Singleton()->PrepareForPluginLoading();
+
+    BrowserThread::PostTask(BrowserThread::FILE,
+                            FROM_HERE,
+                            base::Bind(&PluginLoaderPosix::GetPluginsToLoad,
+                                       make_scoped_refptr(this)));
+  } else {
+    // If we are currently loading plugins, the plugin list might have been
+    // invalidated in the mean time, or might get invalidated before we finish.
+    // We'll wait until we have finished the current run, then try to get them
+    // again from the plugin list. If it has indeed been invalidated, it will
+    // restart plugin loading, otherwise it will immediately run the callback.
+    callbacks_.push_back(base::Bind(&PluginLoaderPosix::GetPluginsWrapper,
+                                    make_scoped_refptr(this), callback));
   }
 }
 
 bool PluginLoaderPosix::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PluginLoaderPosix, message)
     IPC_MESSAGE_HANDLER(UtilityHostMsg_LoadedPlugin, OnPluginLoaded)
     IPC_MESSAGE_HANDLER(UtilityHostMsg_LoadPluginFailed, OnPluginLoadFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 70 matching lines @@
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get());
   process_host_ = host->AsWeakPtr();
   process_host_->DisableSandbox();
 #if defined(OS_MACOSX)
   host->set_child_flags(ChildProcessHost::CHILD_ALLOW_HEAP_EXECUTION);
 #endif
 
   process_host_->Send(new UtilityMsg_LoadPlugins(canonical_list_));
 }
 
+void PluginLoaderPosix::GetPluginsWrapper(
+    const PluginService::GetPluginsCallback& callback,
+    const std::vector<WebPluginInfo>& plugins_unused) {
+  // We are being called after plugin loading has finished, but we don't know
+  // whether the plugin list has been invalidated in the mean time
+  // (and therefore |plugins| might already be stale). So we simply ignore it
+  // and call regular GetPlugins() instead.
+  GetPlugins(callback);
+}
+
 void PluginLoaderPosix::OnPluginLoaded(uint32 index,
                                        const WebPluginInfo& plugin) {
   if (index != next_load_index_) {
     LOG(ERROR) << "Received unexpected plugin load message for "
                << plugin.path.value() << "; index=" << index;
     return;
   }
 
   if (!MaybeAddInternalPlugin(plugin.path))
     loaded_plugins_.push_back(plugin);
@@ skipping 30 matching lines @@
   }
   return false;
 }
 
 bool PluginLoaderPosix::MaybeRunPendingCallbacks() {
   if (next_load_index_ < canonical_list_.size())
     return false;
 
   PluginList::Singleton()->SetPlugins(loaded_plugins_);
 
-  // Only call the first callback with loaded plugins because there may be
-  // some extra plugin paths added since the first callback is added.
-  if (!callbacks_.empty()) {
-    PendingCallback callback = callbacks_.front();
-    callbacks_.pop_front();
-    callback.target_loop->PostTask(
-        FROM_HERE,
-        base::Bind(callback.callback, loaded_plugins_));
+  for (std::vector<PluginService::GetPluginsCallback>::iterator it =
+           callbacks_.begin();
+       it != callbacks_.end(); ++it) {
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(*it, loaded_plugins_));
   }
+  callbacks_.clear();
 
   HISTOGRAM_TIMES("PluginLoaderPosix.LoadDone",
                   (base::TimeTicks::Now() - load_start_time_)
                       * base::Time::kMicrosecondsPerMillisecond);
   load_start_time_ = base::TimeTicks();
 
-  if (!callbacks_.empty()) {
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-        base::Bind(&PluginLoaderPosix::GetPluginsToLoad, this));
-    return false;
-  }
   return true;
 }
 
-PluginLoaderPosix::PendingCallback::PendingCallback(
-    scoped_refptr<base::MessageLoopProxy> loop,
-    const PluginService::GetPluginsCallback& cb)
-    : target_loop(loop),
-      callback(cb) {
-}
-
-PluginLoaderPosix::PendingCallback::~PendingCallback() {
-}
-
 }  // namespace content