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
|
// 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_RENDERER_PEPPER_MESSAGE_CHANNEL_H_
#define CONTENT_RENDERER_PEPPER_MESSAGE_CHANNEL_H_
#include <deque>
#include <list>
#include <map>
#include "base/memory/weak_ptr.h"
#include "ppapi/shared_impl/resource.h"
#include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
#include "third_party/npapi/bindings/npruntime.h"
struct PP_Var;
namespace ppapi {
class ScopedPPVar;
}
namespace content {
class PepperPluginInstanceImpl;
// MessageChannel implements bidirectional postMessage functionality, allowing
// calls from JavaScript to plugins and vice-versa. See
// PPB_Messaging::PostMessage and PPP_Messaging::HandleMessage for more
// information.
//
// Currently, only 1 MessageChannel can exist, to implement postMessage
// functionality for the instance interfaces. In the future, when we create a
// MessagePort type in PPAPI, those may be implemented here as well with some
// refactoring.
// - Separate message ports won't require the passthrough object.
// - The message target won't be limited to instance, and should support
// either plugin-provided or JS objects.
// TODO(dmichael): Add support for separate MessagePorts.
class MessageChannel {
public:
// MessageChannelNPObject is a simple struct that adds a pointer back to a
// MessageChannel instance. This way, we can use an NPObject to allow
// JavaScript interactions without forcing MessageChannel to inherit from
// NPObject.
struct MessageChannelNPObject : public NPObject {
MessageChannelNPObject();
~MessageChannelNPObject();
base::WeakPtr<MessageChannel> message_channel;
};
explicit MessageChannel(PepperPluginInstanceImpl* instance);
~MessageChannel();
// Messages are queued initially. After the PepperPluginInstanceImpl is ready
// to send and handle messages, users of MessageChannel should call
// Start().
void Start();
// Return the NPObject* to which we should forward any calls which aren't
// related to postMessage. Note that this can be NULL; it only gets set if
// there is a scriptable 'InstanceObject' associated with this channel's
// instance.
NPObject* passthrough_object() { return passthrough_object_; }
void SetPassthroughObject(NPObject* passthrough);
NPObject* np_object() { return np_object_; }
PepperPluginInstanceImpl* instance() { return instance_; }
bool GetReadOnlyProperty(NPIdentifier key, NPVariant* value) const;
void SetReadOnlyProperty(PP_Var key, PP_Var value);
// Post a message to the onmessage handler for this channel's instance
// asynchronously.
void PostMessageToJavaScript(PP_Var message_data);
// Post a message to the plugin's HandleMessage function for this channel's
// instance.
void PostMessageToNative(const NPVariant* message_data);
// Post a message to the plugin's HandleBlocking Message function for this
// channel's instance synchronously, and return a result.
void PostBlockingMessageToNative(const NPVariant* message_data,
NPVariant* np_result);
private:
// Struct for storing the result of a NPVariant being converted to a PP_Var.
struct VarConversionResult;
// Post a message to the onmessage handler for this channel's instance
// synchronously. This is used by PostMessageToJavaScript.
void PostMessageToJavaScriptImpl(
const blink::WebSerializedScriptValue& message_data);
void EnqueuePluginMessage(const NPVariant* variant);
void FromV8ValueComplete(VarConversionResult* result_holder,
const ppapi::ScopedPPVar& result_var,
bool success);
void DrainCompletedPluginMessages();
void DrainEarlyMessageQueue();
PepperPluginInstanceImpl* instance_;
// We pass all non-postMessage calls through to the passthrough_object_.
// This way, a plugin can use PPB_Class or PPP_Class_Deprecated and also
// postMessage. This is necessary to support backwards-compatibility, and
// also trusted plugins for which we will continue to support synchronous
// scripting.
NPObject* passthrough_object_;
// The NPObject we use to expose postMessage to JavaScript.
MessageChannelNPObject* np_object_;
std::deque<blink::WebSerializedScriptValue> early_message_queue_;
enum EarlyMessageQueueState {
QUEUE_MESSAGES, // Queue JS messages.
SEND_DIRECTLY, // Post JS messages directly.
};
EarlyMessageQueueState early_message_queue_state_;
// This queue stores vars that are being sent to the plugin. Because
// conversion can happen asynchronously for object types, the queue stores
// the var until all previous vars have been converted and sent. This
// preserves the order in which JS->plugin messages are processed.
//
// Note we rely on raw VarConversionResult* pointers remaining valid after
// calls to push_back or pop_front; hence why we're using list. (deque would
// probably also work, but is less clearly specified).
std::list<VarConversionResult> plugin_message_queue_;
std::map<NPIdentifier, ppapi::ScopedPPVar> internal_properties_;
// This is used to ensure pending tasks will not fire after this object is
// destroyed.
base::WeakPtrFactory<MessageChannel> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(MessageChannel);
};
} // namespace content
#endif // CONTENT_RENDERER_PEPPER_MESSAGE_CHANNEL_H_
|
