src/xwalk-module/xwalk_extension_module.h

   1 #ifndef WRT_XWALK_EXTENSION_MODULE_H_
   2 #define WRT_XWALK_EXTENSION_MODULE_H_
   3
   4 #include <memory>
   5
   6 #include <EWebKit.h>
   7 #include <EWebKit_internal.h>
   8 #include <JavaScriptCore/JavaScript.h>
   9
  10 #include <string>
  11 #include <map>
  12 #include <functional>
  13
  14 #include "xwalk_extension_client.h"
  15
  16 namespace wrt {
  17
  18 class XWalkExtensionClient;
  19 class XWalkModuleSystem;
  20
  21 // Responsible for running the JS code of a XWalkExtension. This includes
  22 // creating and exposing an 'extension' object for the execution context of
  23 // the extension JS code.
  24 //
  25 // We'll create one XWalkExtensionModule per extension/frame pair, so
  26 // there'll be a set of different modules per v8::Context.
  27 class XWalkExtensionModule : public XWalkExtensionClient::InstanceHandler {
  28   public:
  29     XWalkExtensionModule(XWalkExtensionClient* client,
  30                        XWalkModuleSystem* module_system,
  31                        const std::string& extension_name,
  32                        std::function<std::string(void)> getter);
  33     virtual ~XWalkExtensionModule();
  34
  35     // TODO(cmarcelo): Make this return a v8::Handle<v8::Object>, and
  36     // let the module system set it to the appropriated object.
  37     void LoadExtensionCode(JSContextRef context, JSObjectRef native_require);
  38
  39     std::string extension_name() const { return extension_name_; }
  40
  41   private:
  42     class ChunkData {
  43      public:
  44       ChunkData();
  45       ~ChunkData();
  46
  47       ChunkData& operator=(const ChunkData&) = delete;
  48       ChunkData(const ChunkData&) = delete;
  49
  50       uint8_t* data() const { return data_; }
  51       size_t length() const { return length_; }
  52       void set_data(uint8_t* data) { data_ = data; }
  53       void set_length(const size_t length) { length_ = length; }
  54      private:
  55       uint8_t* data_;
  56       size_t length_;
  57     };
  58
  59
  60     // XWalkExtensionClient::InstanceHandler implementation.
  61     virtual void HandleMessageFromNative(const std::string& msg);
  62     virtual void HandleMessageFromNative(const std::string& msg, unsigned char* buffer, std::size_t len);
  63
  64     // Callbacks for JS functions available in 'extension' object.
  65     static JSValueRef PostMessageCallback(JSContextRef context,
  66         JSObjectRef object,
  67         JSObjectRef thisObject,
  68         size_t argumentCount,
  69         const JSValueRef arguments[],
  70         JSValueRef* exception);
  71     static JSValueRef PostDataCallback(JSContextRef context,
  72         JSObjectRef object,
  73         JSObjectRef thisObject,
  74         size_t argumentCount,
  75         const JSValueRef arguments[],
  76         JSValueRef* exception);
  77     static JSValueRef SendSyncMessageCallback(JSContextRef context,
  78         JSObjectRef object,
  79         JSObjectRef thisObject,
  80         size_t argumentCount,
  81         const JSValueRef arguments[],
  82         JSValueRef* exception);
  83     static JSValueRef SendSyncDataCallback(JSContextRef context,
  84         JSObjectRef object,
  85         JSObjectRef thisObject,
  86         size_t argumentCount,
  87         const JSValueRef arguments[],
  88         JSValueRef* exception);
  89     static JSValueRef SendRuntimeMessageCallback(JSContextRef context,
  90         JSObjectRef object,
  91         JSObjectRef thisObject,
  92         size_t argumentCount,
  93         const JSValueRef arguments[],
  94         JSValueRef* exception);
  95     static JSValueRef SendRuntimeAsyncMessageCallback(JSContextRef context,
  96         JSObjectRef object,
  97         JSObjectRef thisObject,
  98         size_t argumentCount,
  99         const JSValueRef arguments[],
 100         JSValueRef* exception);
 101     static JSValueRef SendRuntimeSyncMessageCallback(JSContextRef context,
 102         JSObjectRef object,
 103         JSObjectRef thisObject,
 104         size_t argumentCount,
 105         const JSValueRef arguments[],
 106         JSValueRef* exception);
 107
 108     static JSValueRef SetMessageListenerCallback(JSContextRef context,
 109         JSObjectRef object,
 110         JSObjectRef thisObject,
 111         size_t argumentCount,
 112         const JSValueRef arguments[],
 113         JSValueRef* exception);
 114     static JSValueRef SetDataListenerCallback(JSContextRef context,
 115         JSObjectRef object,
 116         JSObjectRef thisObject,
 117         size_t argumentCount,
 118         const JSValueRef arguments[],
 119         JSValueRef* exception);
 120     static JSValueRef ReceiveChunkDataCallback(JSContextRef context,
 121         JSObjectRef object,
 122         JSObjectRef thisObject,
 123         size_t argumentCount,
 124         const JSValueRef arguments[],
 125         JSValueRef* exception);
 126
 127     static XWalkExtensionModule* GetExtensionModule(JSObjectRef info);
 128
 129     static JSClassDefinition class_definition_;
 130     static JSStaticFunction static_functions_[];
 131     static JSClassRef class_ref_;
 132
 133     JSObjectRef js_object_;
 134
 135     // Function to be called when the extension sends a message to its JS code.
 136     // This value is registered by using 'extension.setMessageListener()'.
 137     JSObjectRef message_listener_;
 138     JSObjectRef data_listener_;
 139
 140     std::string extension_name_;
 141
 142     std::map<int, ChunkData> data_chunk_storage_;
 143
 144     XWalkExtensionClient* client_;
 145     XWalkModuleSystem* module_system_;
 146     int64_t instance_id_;
 147     std::function<std::string(void)> extension_code_getter_;
 148 };
 149
 150 }  // namespace wrt
 151
 152 #endif  // WRT_XWALK_EXTENSION_MODULE_H_