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
168
169
170
171
172
173
174
175
176
177
178
179
180
|
// 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.
#ifndef WEBKIT_GLUE_PLUGINS_PEPPER_PLUGIN_MODULE_H_
#define WEBKIT_GLUE_PLUGINS_PEPPER_PLUGIN_MODULE_H_
#include <map>
#include <set>
#include "base/basictypes.h"
#include "base/native_library.h"
#include "base/process.h"
#include "base/ref_counted.h"
#include "base/scoped_ptr.h"
#include "base/weak_ptr.h"
#include "ppapi/c/pp_module.h"
#include "ppapi/c/ppb.h"
#include "webkit/glue/plugins/pepper_plugin_delegate.h"
class FilePath;
class MessageLoop;
typedef struct NPObject NPObject;
struct PPB_Core;
typedef void* NPIdentifier;
namespace base {
class WaitableEvent;
}
namespace pp {
namespace proxy {
class HostDispatcher;
} // proxy
} // pp
namespace IPC {
struct ChannelHandle;
}
namespace pepper {
class ObjectVar;
class PluginDelegate;
class PluginInstance;
class PluginObject;
// Represents one plugin library loaded into one renderer. This library may
// have multiple instances.
//
// Note: to get from a PP_Instance to a PluginInstance*, use the
// ResourceTracker.
class PluginModule : public base::RefCounted<PluginModule>,
public base::SupportsWeakPtr<PluginModule> {
public:
typedef const void* (*GetInterfaceFunc)(const char*);
typedef int (*PPP_InitializeModuleFunc)(PP_Module, PPB_GetInterface);
typedef void (*PPP_ShutdownModuleFunc)();
struct EntryPoints {
// This structure is POD, with the constructor initializing to NULL.
EntryPoints();
GetInterfaceFunc get_interface;
PPP_InitializeModuleFunc initialize_module;
PPP_ShutdownModuleFunc shutdown_module; // Optional, may be NULL.
};
// You must call one of the Init functions to create a module of the type
// you desire.
PluginModule();
~PluginModule();
// Initializes this module as an internal plugin with the given entrypoints.
// This is used for "plugins" compiled into Chrome. Returns true on success.
// False means that the plugin can not be used.
bool InitAsInternalPlugin(const EntryPoints& entry_points);
// Initializes this module using the given library path as the plugin.
// Returns true on success. False means that the plugin can not be used.
bool InitAsLibrary(const FilePath& path);
// Initializes this module for the given out of process proxy. This takes
// ownership of the given pointer, even in the failure case.
void InitAsProxied(PluginDelegate::OutOfProcessProxy* out_of_process_proxy);
static const PPB_Core* GetCore();
// Returns a pointer to the local GetInterface function for retrieving
// PPB interfaces.
static GetInterfaceFunc GetLocalGetInterfaceFunc();
// Returns the module handle. This may be used before Init() is called (the
// proxy needs this information to set itself up properly).
PP_Module pp_module() const { return pp_module_; }
void set_name(const std::string& name) { name_ = name; }
const std::string& name() const { return name_; }
PluginInstance* CreateInstance(PluginDelegate* delegate);
// Returns "some" plugin instance associated with this module. This is not
// guaranteed to be any one in particular. This is normally used to execute
// callbacks up to the browser layer that are not inherently per-instance,
// but the delegate lives only on the plugin instance so we need one of them.
PluginInstance* GetSomeInstance() const;
// Calls the plugin's GetInterface and returns the given interface pointer,
// which could be NULL.
const void* GetPluginInterface(const char* name) const;
// This module is associated with a set of instances. The PluginInstance
// object declares its association with this module in its destructor and
// releases us in its destructor.
void InstanceCreated(PluginInstance* instance);
void InstanceDeleted(PluginInstance* instance);
// Tracks all live ObjectVar. This is so we can map between PluginModule +
// NPObject and get the ObjectVar corresponding to it. This Add/Remove
// function should be called by the ObjectVar when it is created and
// destroyed.
void AddNPObjectVar(ObjectVar* object_var);
void RemoveNPObjectVar(ObjectVar* object_var);
// Looks up a previously registered ObjectVar for the given NPObject and
// module. Returns NULL if there is no ObjectVar corresponding to the given
// NPObject for the given module. See AddNPObjectVar above.
ObjectVar* ObjectVarForNPObject(NPObject* np_object) const;
// Tracks all live PluginObjects.
void AddPluginObject(PluginObject* plugin_object);
void RemovePluginObject(PluginObject* plugin_object);
private:
// Calls the InitializeModule entrypoint. The entrypoint must have been
// set and the plugin must not be out of process (we don't maintain
// entrypoints in that case).
bool InitializeModule();
PP_Module pp_module_;
// Manages the out of process proxy interface. The presence of this
// pointer indicates that the plugin is running out of process and that the
// entry_points_ aren't valid.
scoped_ptr<PluginDelegate::OutOfProcessProxy> out_of_process_proxy_;
// Holds a reference to the base::NativeLibrary handle if this PluginModule
// instance wraps functions loaded from a library. Can be NULL. If
// |library_| is non-NULL, PluginModule will attempt to unload the library
// during destruction.
base::NativeLibrary library_;
// Contains pointers to the entry points of the actual plugin implementation.
// These will be NULL for out-of-process plugins, which is indicated by the
// presence of the out_of_process_proxy_ value.
EntryPoints entry_points_;
// The name of the module.
std::string name_;
// Non-owning pointers to all instances associated with this module. When
// there are no more instances, this object should be deleted.
typedef std::set<PluginInstance*> PluginInstanceSet;
PluginInstanceSet instances_;
// Tracks all live ObjectVars used by this module so we can map NPObjects to
// the corresponding object. These are non-owning references.
typedef std::map<NPObject*, ObjectVar*> NPObjectToObjectVarMap;;
NPObjectToObjectVarMap np_object_to_object_var_;
typedef std::set<PluginObject*> PluginObjectSet;
PluginObjectSet live_plugin_objects_;
DISALLOW_COPY_AND_ASSIGN(PluginModule);
};
} // namespace pepper
#endif // WEBKIT_GLUE_PLUGINS_PEPPER_PLUGIN_MODULE_H_
|
