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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
// 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.
#ifndef CONTENT_BROWSER_PLUGIN_LIST_H_
#define CONTENT_BROWSER_PLUGIN_LIST_H_
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/callback.h"
#include "base/files/file_path.h"
#include "base/lazy_instance.h"
#include "base/macros.h"
#include "base/synchronization/lock.h"
#include "base/thread_annotations.h"
#include "build/build_config.h"
#include "content/common/content_export.h"
#include "content/public/common/webplugininfo.h"
#include "ppapi/buildflags/buildflags.h"
#if !BUILDFLAG(ENABLE_PLUGINS)
#error "Plugins should be enabled"
#endif
class GURL;
namespace content {
// The PluginList is responsible for loading our NPAPI based plugins. It does
// so in whatever manner is appropriate for the platform. On Windows, it loads
// plugins from a known directory by looking for DLLs which start with "NP",
// and checking to see if they are valid NPAPI libraries. On the Mac, it walks
// the machine-wide and user plugin directories and loads anything that has
// the correct types. On Linux, it walks the plugin directories as well
// (e.g. /usr/lib/browser-plugins/).
// This object is thread safe.
class CONTENT_EXPORT PluginList {
public:
// Gets the one instance of the PluginList.
static PluginList* Singleton();
// Cause the plugin list to refresh next time they are accessed, regardless
// of whether they are already loaded.
void RefreshPlugins();
// Register an internal plugin with the specified plugin information.
// An internal plugin must be registered before it can
// be loaded using PluginList::LoadPlugin().
// If |add_at_beginning| is true the plugin will be added earlier in
// the list so that it can override the MIME types of older registrations.
void RegisterInternalPlugin(const WebPluginInfo& info, bool add_at_beginning);
// Removes a specified internal plugin from the list. The search will match
// on the path from the version info previously registered.
void UnregisterInternalPlugin(const base::FilePath& path);
// Gets a list of all the registered internal plugins.
void GetInternalPlugins(std::vector<WebPluginInfo>* plugins);
// Get all the plugins synchronously, loading them if necessary.
void GetPlugins(std::vector<WebPluginInfo>* plugins);
// Copies the list of plugins into |plugins| without loading them.
// Returns true if the list of plugins is up to date.
bool GetPluginsNoRefresh(std::vector<WebPluginInfo>* plugins);
// Returns a list in |info| containing plugins that are found for
// the given url and mime type (including disabled plugins, for
// which |info->enabled| is false). The mime type which corresponds
// to the URL is optionally returned back in |actual_mime_types| (if
// it is non-NULL), one for each of the plugin info objects found.
// The |allow_wildcard| parameter controls whether this function
// returns plugins which support wildcard mime types (* as the mime
// type). The |info| parameter is required to be non-NULL. The
// list is in order of "most desirable" to "least desirable".
// This will load the plugin list if necessary.
// The return value indicates whether the plugin list was stale.
bool GetPluginInfoArray(const GURL& url,
const std::string& mime_type,
bool allow_wildcard,
std::vector<WebPluginInfo>* info,
std::vector<std::string>* actual_mime_types);
void set_will_load_plugins_callback(const base::RepeatingClosure& callback);
private:
enum LoadingState {
LOADING_STATE_NEEDS_REFRESH,
LOADING_STATE_REFRESHING,
LOADING_STATE_UP_TO_DATE,
};
friend class PluginListTest;
friend struct base::LazyInstanceTraitsBase<PluginList>;
PluginList();
~PluginList();
// The following functions are used to support probing for WebPluginInfo
// using a different instance of this class.
// Computes a list of all plugins to potentially load from all sources.
void GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths);
// Signals that plugin loading will start. This method should be called before
// loading plugins with a different instance of this class. Returns false if
// the plugin list is up to date.
// When loading has finished, SetPlugins() should be called with the list of
// plugins.
bool PrepareForPluginLoading();
// Clears the internal list of Plugins and copies them from the vector.
void SetPlugins(const std::vector<WebPluginInfo>& plugins);
// Load all plugins from the default plugins directory.
void LoadPlugins();
// Removes |plugin_path| from the list of extra plugin paths. Should only be
// called while holding |lock_|.
void RemoveExtraPluginPathLocked(const base::FilePath& plugin_path)
EXCLUSIVE_LOCKS_REQUIRED(lock_);
// Creates a WebPluginInfo structure given a plugin's path. On success
// returns true, with the information being put into "info".
// Returns false if the library couldn't be found, or if it's not a plugin.
bool ReadPluginInfo(const base::FilePath& filename, WebPluginInfo* info);
// Load a specific plugin with full path. Return true iff loading the plugin
// was successful.
bool LoadPluginIntoPluginList(const base::FilePath& filename,
std::vector<WebPluginInfo>* plugins,
WebPluginInfo* plugin_info);
//
// Internals
//
// States whether we will load the plugin list the next time we try to access
// it, whether we are currently in the process of loading it, or whether we
// consider it up to date.
LoadingState loading_state_ GUARDED_BY(lock_);
// Extra plugin paths that we want to search when loading.
std::vector<base::FilePath> extra_plugin_paths_ GUARDED_BY(lock_);
// Holds information about internal plugins.
std::vector<WebPluginInfo> internal_plugins_ GUARDED_BY(lock_);
// A list holding all plugins.
std::vector<WebPluginInfo> plugins_list_ GUARDED_BY(lock_);
// Callback that is invoked whenever the PluginList will reload the plugins.
base::RepeatingClosure will_load_plugins_callback_ GUARDED_BY(lock_);
// Need synchronization for the above members since this object can be
// accessed on multiple threads.
base::Lock lock_;
DISALLOW_COPY_AND_ASSIGN(PluginList);
};
} // namespace content
#endif // CONTENT_BROWSER_PLUGIN_LIST_H_
|
