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
|
// 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 PPAPI_PROXY_PLUGIN_DISPATCHER_H_
#define PPAPI_PROXY_PLUGIN_DISPATCHER_H_
#include <set>
#include <string>
#include "base/basictypes.h"
#include "base/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "base/process.h"
#include "build/build_config.h"
#include "ppapi/c/pp_rect.h"
#include "ppapi/c/pp_instance.h"
#include "ppapi/proxy/dispatcher.h"
#include "ppapi/shared_impl/function_group_base.h"
#include "ppapi/shared_impl/ppapi_preferences.h"
namespace ppapi {
struct Preferences;
class Resource;
class WebKitForwarding;
namespace proxy {
// Used to keep track of per-instance data.
struct InstanceData {
InstanceData();
~InstanceData();
PP_Rect position;
PP_Bool fullscreen; // Used for PPB_Fullscreen.
PP_Bool flash_fullscreen; // Used for PPB_FlashFullscreen.
// When non-0, indicates the callback to execute when mouse lock is lost.
PP_CompletionCallback mouse_lock_callback;
};
class PPAPI_PROXY_EXPORT PluginDispatcher : public Dispatcher {
public:
class PPAPI_PROXY_EXPORT PluginDelegate : public ProxyChannel::Delegate {
public:
// Returns the set used for globally uniquifying PP_Instances. This same
// set must be returned for all channels.
//
// DEREFERENCE ONLY ON THE I/O THREAD.
virtual std::set<PP_Instance>* GetGloballySeenInstanceIDSet() = 0;
// Registers the plugin dispatcher and returns an ID.
// Plugin dispatcher IDs will be used to dispatch messages from the browser.
// Each call to Register() has to be matched with a call to Unregister().
virtual uint32 Register(PluginDispatcher* plugin_dispatcher) = 0;
virtual void Unregister(uint32 plugin_dispatcher_id) = 0;
};
// Constructor for the plugin side. The init and shutdown functions will be
// will be automatically called when requested by the renderer side. The
// module ID will be set upon receipt of the InitializeModule message.
//
// You must call InitPluginWithChannel after the constructor.
PluginDispatcher(base::ProcessHandle remote_process_handle,
GetInterfaceFunc get_interface);
virtual ~PluginDispatcher();
// The plugin side maintains a mapping from PP_Instance to Dispatcher so
// that we can send the messages to the right channel if there are multiple
// renderers sharing the same plugin. This mapping is maintained by
// DidCreateInstance/DidDestroyInstance.
static PluginDispatcher* GetForInstance(PP_Instance instance);
// Same as GetForInstance but retrieves the instance from the given resource
// object as a convenience. Returns NULL on failure.
static PluginDispatcher* GetForResource(const Resource* resource);
// Implements the GetInterface function for the plugin to call to retrieve
// a browser interface.
static const void* GetBrowserInterface(const char* interface_name);
const void* GetPluginInterface(const std::string& interface_name);
// You must call this function before anything else. Returns true on success.
// The delegate pointer must outlive this class, ownership is not
// transferred.
bool InitPluginWithChannel(PluginDelegate* delegate,
const IPC::ChannelHandle& channel_handle,
bool is_client);
// Dispatcher overrides.
virtual bool IsPlugin() const;
virtual bool Send(IPC::Message* msg);
// IPC::Channel::Listener implementation.
virtual bool OnMessageReceived(const IPC::Message& msg);
virtual void OnChannelError();
// Keeps track of which dispatcher to use for each instance, active instances
// and tracks associated data like the current size.
void DidCreateInstance(PP_Instance instance);
void DidDestroyInstance(PP_Instance instance);
// Gets the data for an existing instance, or NULL if the instance id doesn't
// correspond to a known instance.
InstanceData* GetInstanceData(PP_Instance instance);
// Returns the Preferences.
const Preferences& preferences() const { return preferences_; }
// Returns the "new-style" function API for the given interface ID, creating
// it if necessary.
// TODO(brettw) this is in progress. It should be merged with the target
// proxies so there is one list to consult.
FunctionGroupBase* GetFunctionAPI(ApiID id);
uint32 plugin_dispatcher_id() const { return plugin_dispatcher_id_; }
private:
friend class PluginDispatcherTest;
// Notifies all live instances that they're now closed. This is used when
// a renderer crashes or some other error is received.
void ForceFreeAllInstances();
// IPC message handlers.
void OnMsgSupportsInterface(const std::string& interface_name, bool* result);
void OnMsgSetPreferences(const Preferences& prefs);
PluginDelegate* plugin_delegate_;
// Contains all the plugin interfaces we've queried. The mapped value will
// be the pointer to the interface pointer supplied by the plugin if it's
// supported, or NULL if it's not supported. This allows us to cache failures
// and not req-query if a plugin doesn't support the interface.
typedef base::hash_map<std::string, const void*> InterfaceMap;
InterfaceMap plugin_interfaces_;
typedef base::hash_map<PP_Instance, InstanceData> InstanceDataMap;
InstanceDataMap instance_map_;
// The preferences sent from the host. We only want to set this once, which
// is what the received_preferences_ indicates. See OnMsgSetPreferences.
bool received_preferences_;
Preferences preferences_;
uint32 plugin_dispatcher_id_;
DISALLOW_COPY_AND_ASSIGN(PluginDispatcher);
};
} // namespace proxy
} // namespace ppapi
#endif // PPAPI_PROXY_PLUGIN_DISPATCHER_H_
|
