Added automatic update for plugins based on watching file changes.

chrome/browser/plugin_service.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include "chrome/browser/plugin_service.h"
 
 #include "base/command_line.h"
 #include "base/path_service.h"
+#include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chrome_plugin_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/plugin_updater.h"
@@ skipping 30 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::PLUGIN_PROCESS);
        !iter.Done(); ++iter) {
     PluginProcessHost* plugin = static_cast<PluginProcessHost*>(*iter);
     plugin->OnAppActivation();
   }
 }
 #endif
 
+static void PurgePluginListCache(bool reload_pages) {
+  for (RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator();
+       !it.IsAtEnd(); it.Advance()) {
+    it.GetCurrentValue()->Send(new ViewMsg_PurgePluginListCache(reload_pages));
+  }
+}
+
+// Delegate class for monitoring directories.
+class PluginDirWatcherDelegate : public FilePathWatcher::Delegate {
+  virtual void OnFilePathChanged(const FilePath& path) {
+    VLOG(1) << "Watched path changed : " << path.value();
+
+    // Make the plugin list update itself
+    webkit::npapi::PluginList::Singleton()->RefreshPlugins();
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,

[Bernhard Bauer, 2011/01/10 13:27:20]

Is there are reason you're calling this method on the UI thread?

[jam, 2011/01/10 17:18:10]

yep RenderProcessHost lives on the UI thread

[pastarmovj, 2011/01/11 17:17:26]

It was a comment from John back than "since this is being called on the FILE
thread, PluginDirWatcherDelegate will get
called back on that thread.  It can't call RenderProcessHost::iterator since
RenderProcessHost is not thread-safe, and neither is its iterator.  You will
need to post a task to the UI thread to do this."

[pastarmovj, 2011/01/11 17:17:26]

Sorry I didn't post my answer earlier, when I had it written already - that
would have spent you the need to answer as well :)

+        NewRunnableFunction(&PurgePluginListCache, true));
+  }
+  virtual void OnError() {
+    // TODO(pastarmovj): Add some sensible error handling. Maybe silently
+    // stopping the watcher would be enough. Or possibly restart it.
+    NOTREACHED();
+  }
+};
+
 // static
 bool PluginService::enable_chrome_plugins_ = true;
 
 // static
 void PluginService::InitGlobalInstance(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // We first group the plugins and then figure out which groups to disable.
   PluginUpdater::GetInstance()->DisablePluginGroupsFromPrefs(profile);
 
   // Have Chrome plugins write their data to the profile directory.
   GetInstance()->SetChromePluginDataDir(profile->GetPath());
 }
 
 // static
 PluginService* PluginService::GetInstance() {
   return Singleton<PluginService>::get();
 }
 
 // static
 void PluginService::EnableChromePlugins(bool enable) {
   enable_chrome_plugins_ = enable;
 }
 
 PluginService::PluginService()
     : main_message_loop_(MessageLoop::current()),
       resource_dispatcher_host_(NULL),
-      ui_locale_(g_browser_process->GetApplicationLocale()) {
+      ui_locale_(g_browser_process->GetApplicationLocale()),
+      file_watcher_delegate_(new PluginDirWatcherDelegate()) {
   RegisterPepperPlugins();
 
   // Have the NPAPI plugin list search for Chrome plugins as well.
   ChromePluginLib::RegisterPluginsWithNPAPI();
 
   // Load any specified on the command line as well.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   FilePath path = command_line->GetSwitchValuePath(switches::kLoadPlugin);
   if (!path.empty())
     webkit::npapi::PluginList::Singleton()->AddExtraPluginPath(path);
@@ skipping 16 matching lines @@
   }
 #endif
 
 #if defined(OS_CHROMEOS)
   plugin_selection_policy_ = new chromeos::PluginSelectionPolicy;
   plugin_selection_policy_->StartInit();
 #endif
 
   chrome::RegisterInternalGPUPlugin();
 
+  // Start watching for changes in the plugin list. This means watching
+  // for changes in the Windows registry keys and on both Windows and POSIX
+  // watch for changes in the paths that are expected to contain plugins.
 #if defined(OS_WIN)
   hkcu_key_.Create(
       HKEY_CURRENT_USER, webkit::npapi::kRegistryMozillaPlugins, KEY_NOTIFY);
   hklm_key_.Create(
       HKEY_LOCAL_MACHINE, webkit::npapi::kRegistryMozillaPlugins, KEY_NOTIFY);
   if (hkcu_key_.StartWatching()) {
     hkcu_event_.reset(new base::WaitableEvent(hkcu_key_.watch_event()));
     hkcu_watcher_.StartWatching(hkcu_event_.get(), this);
   }
 
   if (hklm_key_.StartWatching()) {
     hklm_event_.reset(new base::WaitableEvent(hklm_key_.watch_event()));
     hklm_watcher_.StartWatching(hklm_event_.get(), this);
   }
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
   // Also find plugins in a user-specific plugins dir,
   // e.g. ~/.config/chromium/Plugins.
   FilePath user_data_dir;
   if (PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
     webkit::npapi::PluginList::Singleton()->AddExtraPluginDir(
         user_data_dir.Append("Plugins"));
   }
 #endif
+  // Get the list of all paths for registering the FilePathWatchers
+  // that will track and if needed reload the list of plugins on runtime.
+  std::vector<FilePath> plugin_dirs_list;

[jam, 2011/01/10 17:18:10]

nit: plugin_dirs_ is enough, especially since list in this case is slightly
confusing since it's a vector and not a list

[pastarmovj, 2011/01/11 17:17:26]

That's true, thanks for the note :) Done.

+  webkit::npapi::PluginList::Singleton()->GetPluginDirectories(
+      &plugin_dirs_list);
+
+  for (size_t i = 0; i < plugin_dirs_list.size(); ++i) {
+    FilePathWatcher* watcher = new FilePathWatcher();
+    VLOG(1) << "Watching for changes in : " << plugin_dirs_list[i].value();

[Bernhard Bauer, 2011/01/10 13:27:20]

Nit: no space before the colon.

[pastarmovj, 2011/01/11 17:17:26]

Done.

+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        NewRunnableFunction(
+            &PluginService::RegisterFilePathWatcher,
+            watcher, plugin_dirs_list[i], file_watcher_delegate_));
+    file_watchers_.push_back(watcher);
+  }
 
   registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                  NotificationService::AllSources());
 #if defined(OS_MACOSX)
   // We need to know when the browser comes forward so we can bring modal plugin
   // windows forward too.
   registrar_.Add(this, NotificationType::APP_ACTIVATED,
                  NotificationService::AllSources());
 #endif
   registrar_.Add(this, NotificationType::PLUGIN_ENABLE_STATUS_CHANGED,
                  NotificationService::AllSources());
 }
 
 PluginService::~PluginService() {
 #if defined(OS_WIN)
   // Release the events since they're owned by RegKey, not WaitableEvent.
   hkcu_watcher_.StopWatching();
   hklm_watcher_.StopWatching();
   hkcu_event_->Release();
   hklm_event_->Release();
 #endif
+  // Delete the file watchers to release the refcounted delegates.
+  STLDeleteElements(&file_watchers_);
 }
 
 void PluginService::LoadChromePlugins(
     ResourceDispatcherHost* resource_dispatcher_host) {
   if (!enable_chrome_plugins_)
     return;
 
   resource_dispatcher_host_ = resource_dispatcher_host;
   ChromePluginLib::LoadChromePlugins(GetCPBrowserFuncsForBrowser());
 }
@@ skipping 116 matching lines @@
       *actual_mime_type = actual_mime_types[allowed_index];
     return true;
   }
   return false;
 #else
   return webkit::npapi::PluginList::Singleton()->GetPluginInfo(
       url, mime_type, allow_wildcard, info, actual_mime_type);
 #endif
 }
 
-static void PurgePluginListCache(bool reload_pages) {
-  for (RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator();
-       !it.IsAtEnd(); it.Advance()) {
-    it.GetCurrentValue()->Send(new ViewMsg_PurgePluginListCache(reload_pages));
-  }
-}
-
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_.get()) {
     hkcu_key_.StartWatching();
   } else {
     hklm_key_.StartWatching();
   }
 
   webkit::npapi::PluginList::Singleton()->RefreshPlugins();
   PurgePluginListCache(true);
+#else
+  // This event should only get signaled on a Windows machine.
+  NOTREACHED();
 #endif  // defined(OS_WIN)
 }
 
 static void ForceShutdownPlugin(const FilePath& plugin_path) {
   PluginProcessHost* plugin =
       PluginService::GetInstance()->FindPluginProcess(plugin_path);
   if (plugin)
     plugin->ForceShutdown();
 }
 
@@ skipping 44 matching lines @@
                               NewRunnableFunction(&NotifyPluginsOfActivation));
       break;
     }
 #endif
 
     case NotificationType::PLUGIN_ENABLE_STATUS_CHANGED: {
       PurgePluginListCache(false);
       break;
     }
     default:
-      DCHECK(false);
+      NOTREACHED();
   }
 }
 
 bool PluginService::PrivatePluginAllowedForURL(const FilePath& plugin_path,
                                                const GURL& url) {
   if (url.is_empty())
     return true;  // Caller wants all plugins.
 
   PrivatePluginMap::iterator it = private_plugins_.find(plugin_path);
   if (it == private_plugins_.end())
@@ skipping 21 matching lines @@
     info.mime_types = ASCIIToWide(JoinString(plugins[i].mime_types, '|'));
 
     // These NPAPI entry points will never be called.  TODO(darin): Come up
     // with a cleaner way to register pepper plugins with the NPAPI PluginList,
     // or perhaps refactor the PluginList to be less specific to NPAPI.
     memset(&info.entry_points, 0, sizeof(info.entry_points));
 
     webkit::npapi::PluginList::Singleton()->RegisterInternalPlugin(info);
   }
 }
+
+// static
+void PluginService::RegisterFilePathWatcher(
+    FilePathWatcher *watcher,
+    const FilePath& path,
+    FilePathWatcher::Delegate* delegate) {
+  DCHECK(watcher->Watch(path, delegate));

[Bernhard Bauer, 2011/01/10 13:27:20]

Isn't this whole line a no-op in a release build? I think you want to do

  bool result = ...;
  DCHECK(result);

[pastarmovj, 2011/01/11 17:17:26]

True. Sorry about that.

+}