common/extension_adapter.h

   1 // Copyright (c) 2013 Intel Corporation. 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 COMMON_EXTENSION_ADAPTER_H_
   6 #define COMMON_EXTENSION_ADAPTER_H_
   7
   8 #include <cstdlib>
   9 #include <map>
  10 #include "common/XW_Extension.h"
  11 #include "common/XW_Extension_SyncMessage.h"
  12
  13 namespace internal {
  14
  15 int32_t InitializeExtension(XW_Extension extension,
  16                             XW_GetInterface get_interface,
  17                             const char* name,
  18                             const char* api,
  19                             const char** entry_points,
  20                             XW_CreatedInstanceCallback created,
  21                             XW_DestroyedInstanceCallback destroyed,
  22                             XW_HandleMessageCallback handle_message,
  23                             XW_HandleSyncMessageCallback handle_sync_message);
  24
  25 void PostMessage(XW_Instance instance, const char* message);
  26 void SetSyncReply(XW_Instance instance, const char* reply);
  27
  28 }  // namespace internal
  29
  30 class ContextAPI {
  31  public:
  32   explicit ContextAPI(XW_Instance instance) : instance_(instance) {}
  33
  34   void PostMessage(const char* message) {
  35     internal::PostMessage(instance_, message);
  36   }
  37   void SetSyncReply(const char* reply) {
  38     internal::SetSyncReply(instance_, reply);
  39   }
  40
  41  private:
  42   XW_Instance instance_;
  43 };
  44
  45 template <class T>
  46 class ExtensionAdapter {
  47  public:
  48   static int32_t Initialize(XW_Extension extension,
  49                             XW_GetInterface get_interface);
  50
  51  private:
  52   static void DidCreateInstance(XW_Instance instance);
  53   static void DidDestroyInstance(XW_Instance instance);
  54
  55   static void HandleMessage(XW_Instance instance, const char* message);
  56   static void HandleSyncMessage(XW_Instance instance, const char* message);
  57
  58   typedef std::map<XW_Instance, T*> InstanceMap;
  59   static InstanceMap g_instances;
  60 };
  61
  62 template <class T>
  63 typename ExtensionAdapter<T>::InstanceMap ExtensionAdapter<T>::g_instances;
  64
  65 template <class T>
  66 int32_t ExtensionAdapter<T>::Initialize(XW_Extension extension,
  67                                         XW_GetInterface get_interface) {
  68   return internal::InitializeExtension(
  69       extension, get_interface, T::name, T::GetJavaScript(), T::entry_points,
  70       DidCreateInstance, DidDestroyInstance, HandleMessage, HandleSyncMessage);
  71 }
  72
  73 template <class T>
  74 void ExtensionAdapter<T>::DidCreateInstance(XW_Instance instance) {
  75   g_instances[instance] = new T(new ContextAPI(instance));
  76 }
  77
  78 template <class T>
  79 void ExtensionAdapter<T>::DidDestroyInstance(XW_Instance instance) {
  80   delete g_instances[instance];
  81   g_instances.erase(instance);
  82 }
  83
  84 template <class T>
  85 void ExtensionAdapter<T>::HandleMessage(XW_Instance instance,
  86                                         const char* message) {
  87   g_instances[instance]->HandleMessage(message);
  88 }
  89
  90
  91 template <class T>
  92 void ExtensionAdapter<T>::HandleSyncMessage(XW_Instance instance,
  93                                             const char* message) {
  94   g_instances[instance]->HandleSyncMessage(message);
  95 }
  96
  97 #define DEFINE_XWALK_EXTENSION(NAME)                                    \
  98   int32_t XW_Initialize(XW_Extension extension,                         \
  99                         XW_GetInterface get_interface) {                \
 100     return ExtensionAdapter<NAME>::Initialize(extension, get_interface); \
 101   }
 102
 103 #endif  // COMMON_EXTENSION_ADAPTER_H_