1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// Copyright (c) 2011 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.
#ifndef CONTENT_COMMON_PEPPER_PLUGIN_REGISTRY_H_
#define CONTENT_COMMON_PEPPER_PLUGIN_REGISTRY_H_
#pragma once
#include <list>
#include <map>
#include <string>
#include <vector>
#include "base/file_path.h"
#include "content/common/content_export.h"
#include "ppapi/proxy/proxy_channel.h"
#include "webkit/plugins/ppapi/plugin_delegate.h"
#include "webkit/plugins/ppapi/plugin_module.h"
#include "webkit/plugins/webplugininfo.h"
struct CONTENT_EXPORT PepperPluginInfo {
PepperPluginInfo();
~PepperPluginInfo();
webkit::WebPluginInfo ToWebPluginInfo() const;
// Indicates internal plugins for which there's not actually a library.
// These plugins are implemented in the Chrome binary using a separate set
// of entry points (see internal_entry_points below).
// Defaults to false.
bool is_internal;
// True when this plugin should be run out of process. Defaults to false.
bool is_out_of_process;
// Whether the plugin is enabled. Defaults to true.
bool enabled;
FilePath path; // Internal plugins have "internal-[name]" as path.
std::string name;
std::string description;
std::string version;
std::vector<webkit::WebPluginMimeType> mime_types;
// When is_internal is set, this contains the function pointers to the
// entry points for the internal plugins.
webkit::ppapi::PluginModule::EntryPoints internal_entry_points;
};
// Constructs a PepperPluginInfo from a WebPluginInfo. Returns false if
// the operation is not possible, in particular the WebPluginInfo::type
// must be one of the pepper types.
bool MakePepperPluginInfo(const webkit::WebPluginInfo& webplugin_info,
PepperPluginInfo* pepper_info);
// This class holds references to all of the known pepper plugin modules.
//
// It keeps two lists. One list of preloaded in-process modules, and one list
// is a list of all live modules (some of which may be out-of-process and hence
// not preloaded).
class PepperPluginRegistry
: public webkit::ppapi::PluginDelegate::ModuleLifetime,
public ppapi::proxy::ProxyChannel::Delegate {
public:
~PepperPluginRegistry();
static PepperPluginRegistry* GetInstance();
// Computes the list of known pepper plugins.
//
// This method is static so that it can be used by the browser process, which
// has no need to load the pepper plugin modules. It will re-compute the
// plugin list every time it is called. Generally, code in the registry should
// be using the cached plugin_list_ instead.
CONTENT_EXPORT static void ComputeList(
std::vector<PepperPluginInfo>* plugins);
// Loads the (native) libraries but does not initialize them (i.e., does not
// call PPP_InitializeModule). This is needed by the zygote on Linux to get
// access to the plugins before entering the sandbox.
static void PreloadModules();
// Retrieves the information associated with the given plugin info. The
// return value will be NULL if there is no such plugin.
//
// The returned pointer is owned by the PluginRegistry.
const PepperPluginInfo* GetInfoForPlugin(
const webkit::WebPluginInfo& info);
// Returns an existing loaded module for the given path. It will search for
// both preloaded in-process or currently active (non crashed) out-of-process
// plugins matching the given name. Returns NULL if the plugin hasn't been
// loaded.
webkit::ppapi::PluginModule* GetLiveModule(const FilePath& path);
// Notifies the registry that a new non-preloaded module has been created.
// This is normally called for out-of-process plugins. Once this is called,
// the module is available to be returned by GetModule(). The module will
// automatically unregister itself by calling PluginModuleDestroyed().
void AddLiveModule(const FilePath& path, webkit::ppapi::PluginModule* module);
// ModuleLifetime implementation.
virtual void PluginModuleDead(webkit::ppapi::PluginModule* dead_module);
private:
PepperPluginRegistry();
// ProxyChannel::Delegate implementation.
virtual base::MessageLoopProxy* GetIPCMessageLoop();
virtual base::WaitableEvent* GetShutdownEvent();
// All known pepper plugins.
std::vector<PepperPluginInfo> plugin_list_;
// Plugins that have been preloaded so they can be executed in-process in
// the renderer (the sandbox prevents on-demand loading).
typedef std::map<FilePath, scoped_refptr<webkit::ppapi::PluginModule> >
OwningModuleMap;
OwningModuleMap preloaded_modules_;
// A list of non-owning pointers to all currently-live plugin modules. This
// includes both preloaded ones in preloaded_modules_, and out-of-process
// modules whose lifetime is managed externally. This will contain only
// non-crashed modules. If an out-of-process module crashes, it may
// continue as long as there are WebKit references to it, but it will not
// appear in this list.
typedef std::map<FilePath, webkit::ppapi::PluginModule*> NonOwningModuleMap;
NonOwningModuleMap live_modules_;
DISALLOW_COPY_AND_ASSIGN(PepperPluginRegistry);
};
#endif // CONTENT_COMMON_PEPPER_PLUGIN_REGISTRY_H_
|
