content/plugin/plugin_thread.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/plugin/plugin_thread.h"
   6
   7 #include "build/build_config.h"
   8
   9 #if defined(TOOLKIT_GTK)
  10 #include <gtk/gtk.h>
  11 #elif defined(OS_MACOSX)
  12 #include <CoreFoundation/CoreFoundation.h>
  13 #endif
  14
  15 #include <string>
  16 #include <vector>
  17
  18 #include "base/bind.h"
  19 #include "base/command_line.h"
  20 #include "base/lazy_instance.h"
  21 #include "base/process_util.h"
  22 #include "base/threading/thread_local.h"
  23 #include "content/common/child_process.h"
  24 #include "content/common/npobject_util.h"
  25 #include "content/common/plugin_messages.h"
  26 #include "content/public/common/content_switches.h"
  27 #include "content/public/plugin/content_plugin_client.h"
  28 #include "ipc/ipc_channel_handle.h"
  29 #include "webkit/glue/webkit_glue.h"
  30 #include "webkit/plugins/npapi/plugin_lib.h"
  31 #include "webkit/plugins/npapi/plugin_list.h"
  32 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
  33
  34 #if defined(TOOLKIT_GTK)
  35 #include "ui/gfx/gtk_util.h"
  36 #endif
  37
  38 #if defined(USE_X11)
  39 #include "ui/base/x/x11_util.h"
  40 #endif
  41
  42 namespace content {
  43
  44 namespace {
  45
  46 class EnsureTerminateMessageFilter : public IPC::ChannelProxy::MessageFilter {
  47  public:
  48   EnsureTerminateMessageFilter() {}
  49
  50  protected:
  51   virtual ~EnsureTerminateMessageFilter() {}
  52
  53   // IPC::ChannelProxy::MessageFilter:
  54   virtual void OnChannelError() {
  55     // How long we wait before forcibly shutting down the process.
  56     const base::TimeDelta kPluginProcessTerminateTimeout =
  57         base::TimeDelta::FromSeconds(3);
  58     // Ensure that we don't wait indefinitely for the plugin to shutdown.
  59     // as the browser does not terminate plugin processes on shutdown.
  60     // We achieve this by posting an exit process task on the IO thread.
  61     MessageLoop::current()->PostDelayedTask(
  62         FROM_HERE,
  63         base::Bind(&EnsureTerminateMessageFilter::Terminate, this),
  64         kPluginProcessTerminateTimeout);
  65   }
  66
  67  private:
  68   void Terminate() {
  69     base::KillProcess(base::GetCurrentProcessHandle(), 0, false);
  70   }
  71 };
  72
  73 }  // namespace
  74
  75 static base::LazyInstance<base::ThreadLocalPointer<PluginThread> > lazy_tls =
  76     LAZY_INSTANCE_INITIALIZER;
  77
  78 PluginThread::PluginThread()
  79     : preloaded_plugin_module_(NULL) {
  80   FilePath plugin_path = CommandLine::ForCurrentProcess()->GetSwitchValuePath(
  81       switches::kPluginPath);
  82
  83   lazy_tls.Pointer()->Set(this);
  84 #if defined(USE_AURA)
  85   // TODO(saintlou):
  86 #elif defined(TOOLKIT_GTK)
  87   {
  88     // XEmbed plugins assume they are hosted in a Gtk application, so we need
  89     // to initialize Gtk in the plugin process.
  90     // g_thread_init API is deprecated since glib 2.31.0, see release note:
  91     // http://mail.gnome.org/archives/gnome-announce-list/2011-October/msg00041.html
  92 #if !(GLIB_CHECK_VERSION(2, 31, 0))
  93     g_thread_init(NULL);
  94 #endif
  95
  96     // Flash has problems receiving clicks with newer GTKs due to the
  97     // client-side windows change.  To be safe, we just always set the
  98     // backwards-compat environment variable.
  99     setenv("GDK_NATIVE_WINDOWS", "1", 1);
 100
 101     gfx::GtkInitFromCommandLine(*CommandLine::ForCurrentProcess());
 102
 103     // GTK after 2.18 resets the environment variable.  But if we're using
 104     // nspluginwrapper, that means it'll spawn its subprocess without the
 105     // environment variable!  So set it again.
 106     setenv("GDK_NATIVE_WINDOWS", "1", 1);
 107   }
 108
 109   ui::SetDefaultX11ErrorHandlers();
 110 #endif
 111
 112   PatchNPNFunctions();
 113
 114   // Preload the library to avoid loading, unloading then reloading
 115   preloaded_plugin_module_ = base::LoadNativeLibrary(plugin_path, NULL);
 116
 117   scoped_refptr<webkit::npapi::PluginLib> plugin(
 118       webkit::npapi::PluginLib::CreatePluginLib(plugin_path));
 119   if (plugin.get()) {
 120     plugin->NP_Initialize();
 121     // For OOP plugins the plugin dll will be unloaded during process shutdown
 122     // time.
 123     plugin->set_defer_unload(true);
 124   }
 125
 126   GetContentClient()->plugin()->PluginProcessStarted(
 127       plugin.get() ? plugin->plugin_info().name : string16());
 128
 129   GetContentClient()->AddNPAPIPlugins(
 130       webkit::npapi::PluginList::Singleton());
 131
 132   // Certain plugins, such as flash, steal the unhandled exception filter
 133   // thus we never get crash reports when they fault. This call fixes it.
 134   message_loop()->set_exception_restoration(true);
 135   channel()->AddFilter(new EnsureTerminateMessageFilter());
 136 }
 137
 138 PluginThread::~PluginThread() {
 139   if (preloaded_plugin_module_) {
 140     base::UnloadNativeLibrary(preloaded_plugin_module_);
 141     preloaded_plugin_module_ = NULL;
 142   }
 143   NPChannelBase::CleanupChannels();
 144   webkit::npapi::PluginLib::UnloadAllPlugins();
 145
 146   if (webkit_glue::ShouldForcefullyTerminatePluginProcess())
 147     base::KillProcess(base::GetCurrentProcessHandle(), 0, /* wait= */ false);
 148
 149   lazy_tls.Pointer()->Set(NULL);
 150 }
 151
 152 PluginThread* PluginThread::current() {
 153   return lazy_tls.Pointer()->Get();
 154 }
 155
 156 bool PluginThread::OnControlMessageReceived(const IPC::Message& msg) {
 157   bool handled = true;
 158   IPC_BEGIN_MESSAGE_MAP(PluginThread, msg)
 159     IPC_MESSAGE_HANDLER(PluginProcessMsg_CreateChannel, OnCreateChannel)
 160     IPC_MESSAGE_HANDLER(PluginProcessMsg_NotifyRenderersOfPendingShutdown,
 161                         OnNotifyRenderersOfPendingShutdown)
 162     IPC_MESSAGE_UNHANDLED(handled = false)
 163   IPC_END_MESSAGE_MAP()
 164   return handled;
 165 }
 166
 167 void PluginThread::OnCreateChannel(int renderer_id,
 168                                    bool incognito) {
 169   scoped_refptr<PluginChannel> channel(PluginChannel::GetPluginChannel(
 170       renderer_id, ChildProcess::current()->io_message_loop_proxy()));
 171   IPC::ChannelHandle channel_handle;
 172   if (channel.get()) {
 173     channel_handle.name = channel->channel_handle().name;
 174 #if defined(OS_POSIX)
 175     // On POSIX, pass the renderer-side FD.
 176     channel_handle.socket =
 177         base::FileDescriptor(channel->TakeRendererFileDescriptor(), true);
 178 #endif
 179     channel->set_incognito(incognito);
 180   }
 181
 182   Send(new PluginProcessHostMsg_ChannelCreated(channel_handle));
 183 }
 184
 185 void PluginThread::OnNotifyRenderersOfPendingShutdown() {
 186   PluginChannel::NotifyRenderersOfPendingShutdown();
 187 }
 188
 189 }  // namespace content