src/content/renderer/pepper/message_channel.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_RENDERER_PEPPER_MESSAGE_CHANNEL_H_
   6 #define CONTENT_RENDERER_PEPPER_MESSAGE_CHANNEL_H_
   7
   8 #include <deque>
   9 #include <list>
  10 #include <map>
  11
  12 #include "base/memory/weak_ptr.h"
  13 #include "ppapi/shared_impl/resource.h"
  14 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
  15 #include "third_party/npapi/bindings/npruntime.h"
  16
  17 struct PP_Var;
  18
  19 namespace ppapi {
  20 class ScopedPPVar;
  21 }
  22
  23 namespace content {
  24
  25 class PepperPluginInstanceImpl;
  26
  27 // MessageChannel implements bidirectional postMessage functionality, allowing
  28 // calls from JavaScript to plugins and vice-versa. See
  29 // PPB_Messaging::PostMessage and PPP_Messaging::HandleMessage for more
  30 // information.
  31 //
  32 // Currently, only 1 MessageChannel can exist, to implement postMessage
  33 // functionality for the instance interfaces.  In the future, when we create a
  34 // MessagePort type in PPAPI, those may be implemented here as well with some
  35 // refactoring.
  36 //   - Separate message ports won't require the passthrough object.
  37 //   - The message target won't be limited to instance, and should support
  38 //     either plugin-provided or JS objects.
  39 // TODO(dmichael):  Add support for separate MessagePorts.
  40 class MessageChannel {
  41  public:
  42   // MessageChannelNPObject is a simple struct that adds a pointer back to a
  43   // MessageChannel instance.  This way, we can use an NPObject to allow
  44   // JavaScript interactions without forcing MessageChannel to inherit from
  45   // NPObject.
  46   struct MessageChannelNPObject : public NPObject {
  47     MessageChannelNPObject();
  48     ~MessageChannelNPObject();
  49
  50     base::WeakPtr<MessageChannel> message_channel;
  51   };
  52
  53   explicit MessageChannel(PepperPluginInstanceImpl* instance);
  54   ~MessageChannel();
  55
  56   // Messages are queued initially. After the PepperPluginInstanceImpl is ready
  57   // to send and handle messages, users of MessageChannel should call
  58   // Start().
  59   void Start();
  60
  61   // Return the NPObject* to which we should forward any calls which aren't
  62   // related to postMessage.  Note that this can be NULL;  it only gets set if
  63   // there is a scriptable 'InstanceObject' associated with this channel's
  64   // instance.
  65   NPObject* passthrough_object() { return passthrough_object_; }
  66   void SetPassthroughObject(NPObject* passthrough);
  67
  68   NPObject* np_object() { return np_object_; }
  69
  70   PepperPluginInstanceImpl* instance() { return instance_; }
  71
  72   bool GetReadOnlyProperty(NPIdentifier key, NPVariant* value) const;
  73   void SetReadOnlyProperty(PP_Var key, PP_Var value);
  74
  75   // Post a message to the onmessage handler for this channel's instance
  76   // asynchronously.
  77   void PostMessageToJavaScript(PP_Var message_data);
  78
  79   // Post a message to the plugin's HandleMessage function for this channel's
  80   // instance.
  81   void PostMessageToNative(const NPVariant* message_data);
  82
  83   // Post a message to the plugin's HandleBlocking Message function for this
  84   // channel's instance synchronously, and return a result.
  85   void PostBlockingMessageToNative(const NPVariant* message_data,
  86                                    NPVariant* np_result);
  87
  88  private:
  89   // Struct for storing the result of a NPVariant being converted to a PP_Var.
  90   struct VarConversionResult;
  91
  92   // Post a message to the onmessage handler for this channel's instance
  93   // synchronously.  This is used by PostMessageToJavaScript.
  94   void PostMessageToJavaScriptImpl(
  95       const blink::WebSerializedScriptValue& message_data);
  96
  97   void EnqueuePluginMessage(const NPVariant* variant);
  98
  99   void FromV8ValueComplete(VarConversionResult* result_holder,
 100                            const ppapi::ScopedPPVar& result_var,
 101                            bool success);
 102
 103   void DrainCompletedPluginMessages();
 104   void DrainEarlyMessageQueue();
 105
 106   PepperPluginInstanceImpl* instance_;
 107
 108   // We pass all non-postMessage calls through to the passthrough_object_.
 109   // This way, a plugin can use PPB_Class or PPP_Class_Deprecated and also
 110   // postMessage.  This is necessary to support backwards-compatibility, and
 111   // also trusted plugins for which we will continue to support synchronous
 112   // scripting.
 113   NPObject* passthrough_object_;
 114
 115   // The NPObject we use to expose postMessage to JavaScript.
 116   MessageChannelNPObject* np_object_;
 117
 118   std::deque<blink::WebSerializedScriptValue> early_message_queue_;
 119   enum EarlyMessageQueueState {
 120     QUEUE_MESSAGES,  // Queue JS messages.
 121     SEND_DIRECTLY,   // Post JS messages directly.
 122   };
 123   EarlyMessageQueueState early_message_queue_state_;
 124
 125   // This queue stores vars that are being sent to the plugin. Because
 126   // conversion can happen asynchronously for object types, the queue stores
 127   // the var until all previous vars have been converted and sent. This
 128   // preserves the order in which JS->plugin messages are processed.
 129   //
 130   // Note we rely on raw VarConversionResult* pointers remaining valid after
 131   // calls to push_back or pop_front; hence why we're using list. (deque would
 132   // probably also work, but is less clearly specified).
 133   std::list<VarConversionResult> plugin_message_queue_;
 134
 135   std::map<NPIdentifier, ppapi::ScopedPPVar> internal_properties_;
 136
 137   // This is used to ensure pending tasks will not fire after this object is
 138   // destroyed.
 139   base::WeakPtrFactory<MessageChannel> weak_ptr_factory_;
 140
 141   DISALLOW_COPY_AND_ASSIGN(MessageChannel);
 142 };
 143
 144 }  // namespace content
 145
 146 #endif  // CONTENT_RENDERER_PEPPER_MESSAGE_CHANNEL_H_