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();

[pastarmovj, 2011/01/12 16:51:09]

Problem here was that PurgePluginCache can be executed between an Async call to
a plugin and before it's been processed. This happens in the
PluginThreadAsyncCall UI test. The problem turned up in mac because MacOS
produces some directory change notifications even when there are none (the
frequency is not so high but it turns out to be a access-time change
notification - so it happens more or less when there is plugin activity and we
might want to disable this for mac altogether). However the problem is not
limited to a specific platform and should be tackled in general.

+  }
+  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;
+  webkit::npapi::PluginList::Singleton()->GetPluginDirectories(
+      &plugin_dirs);
+
+  for (size_t i = 0; i < plugin_dirs.size(); ++i) {
+    FilePathWatcher* watcher = new FilePathWatcher();
+    // FilePathWatcher can not handle non-absolute paths under windows.
+#if defined(OS_WIN)
+    if(!plugin_dirs[i].IsAbsolute())
+      continue;
+#endif
+    VLOG(1) << "Watching for changes in: " << plugin_dirs[i].value();
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        NewRunnableFunction(
+            &PluginService::RegisterFilePathWatcher,
+            watcher, plugin_dirs[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());
@@ skipping 139 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);

[pastarmovj, 2011/01/12 16:51:09]

I can imagine this will lead to the same problem (only that it doesn't happen
all too often)

+#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();
 }
 
 void PluginService::Observe(NotificationType type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_LOADED: {
       const Extension* extension = Details<const Extension>(details).ptr();
       bool plugins_changed = false;
       for (size_t i = 0; i < extension->plugins().size(); ++i) {
         const Extension::PluginInfo& plugin = extension->plugins()[i];
         webkit::npapi::PluginList::Singleton()->RefreshPlugins();
         webkit::npapi::PluginList::Singleton()->AddExtraPluginPath(plugin.path);
         plugins_changed = true;
         if (!plugin.is_public)
           private_plugins_[plugin.path] = extension->url();
       }
       if (plugins_changed)
         PurgePluginListCache(false);

[pastarmovj, 2011/01/12 16:51:09]

Dito.

       break;
     }
 
     case NotificationType::EXTENSION_UNLOADED: {
       const Extension* extension =
           Details<UnloadedExtensionInfo>(details)->extension;
       bool plugins_changed = false;
       for (size_t i = 0; i < extension->plugins().size(); ++i) {
         const Extension::PluginInfo& plugin = extension->plugins()[i];
         BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                                 NewRunnableFunction(&ForceShutdownPlugin,
                                                     plugin.path));
         webkit::npapi::PluginList::Singleton()->RefreshPlugins();
         webkit::npapi::PluginList::Singleton()->RemoveExtraPluginPath(
             plugin.path);
         plugins_changed = true;
         if (!plugin.is_public)
           private_plugins_.erase(plugin.path);
       }
       if (plugins_changed)
         PurgePluginListCache(false);

[pastarmovj, 2011/01/12 16:51:09]

Dito.

       break;
     }
 
 #if defined(OS_MACOSX)
     case NotificationType::APP_ACTIVATED: {
       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                               NewRunnableFunction(&NotifyPluginsOfActivation));
       break;
     }
 #endif
 
     case NotificationType::PLUGIN_ENABLE_STATUS_CHANGED: {
       PurgePluginListCache(false);

[pastarmovj, 2011/01/12 16:51:09]

Dito. Here we need additional RefreshPlugins call to make plugin policy changes
work immediately after a change. (proposed in the
http://codereview.chromium.org/6157008/ CL)

       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) {
+  bool result = watcher->Watch(path, delegate);
+  DCHECK(result);
+}