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
|
// 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 "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();
// Converts an NPVariant to a PP_Var. This occurs asynchronously and
// NPVariantToPPVarComplete will be called upon completion.
void NPVariantToPPVar(const NPVariant* variant);
// Post a message to the onmessage handler for this channel's instance
// asynchronously.
void PostMessageToJavaScript(PP_Var message_data);
// Post a message to the PPP_Instance HandleMessage function for this
// channel's instance.
void PostMessageToNative(PP_Var message_data);
// 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_;
}
// Messages sent to JavaScript are queued by default. After the DOM is
// set up for the plugin, users of MessageChannel should call
// StopQueueingJavaScriptMessages to start dispatching messages to JavaScript.
void QueueJavaScriptMessages();
void StopQueueingJavaScriptMessages();
private:
// Struct for storing the result of a NPVariant being converted to a PP_Var.
struct VarConversionResult;
// This is called when an NPVariant is finished being converted.
// |result_iteartor| is an iterator into |converted_var_queue_| where the
// result should be stored.
void NPVariantToPPVarComplete(
const std::list<VarConversionResult>::iterator& result_iterator,
const ppapi::ScopedPPVar& result,
bool success);
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_;
// Post a message to the onmessage handler for this channel's instance
// synchronously. This is used by PostMessageToJavaScript.
void PostMessageToJavaScriptImpl(
const WebKit::WebSerializedScriptValue& message_data);
// Post a message to the PPP_Instance HandleMessage function for this
// channel's instance. This is used by PostMessageToNative.
void PostMessageToNativeImpl(PP_Var message_data);
void DrainEarlyMessageQueue();
// This is used to ensure pending tasks will not fire after this object is
// destroyed.
base::WeakPtrFactory<MessageChannel> weak_ptr_factory_;
// TODO(teravest): Remove all the tricky DRAIN_CANCELLED logic once
// PluginInstance::ResetAsProxied() is gone.
std::deque<WebKit::WebSerializedScriptValue> early_message_queue_;
enum EarlyMessageQueueState {
QUEUE_MESSAGES, // Queue JS messages.
SEND_DIRECTLY, // Post JS messages directly.
DRAIN_PENDING, // Drain queue, then transition to DIRECT.
DRAIN_CANCELLED // Preempt drain, go back to QUEUE.
};
EarlyMessageQueueState early_message_queue_state_;
// This queue stores vars that have been converted from NPVariants. Because
// conversion can happen asynchronously, the queue stores the var until all
// previous vars have been converted before calling PostMessage to ensure that
// the order in which messages are processed is preserved.
std::list<VarConversionResult> converted_var_queue_;
DISALLOW_COPY_AND_ASSIGN(MessageChannel);
};
} // namespace content
#endif // CONTENT_RENDERER_PEPPER_MESSAGE_CHANNEL_H_
|
