src/xwalk/extensions/common/xwalk_external_extension.cc

   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 #include "xwalk/extensions/common/xwalk_external_extension.h"
   6
   7 #include <string>
   8 #include <vector>
   9 #include "base/files/file_path.h"
  10 #include "base/json/json_writer.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/logging.h"
  13 #include "base/values.h"
  14 #include "xwalk/extensions/common/xwalk_external_adapter.h"
  15
  16 namespace xwalk {
  17 namespace extensions {
  18
  19 XWalkExternalExtension::XWalkExternalExtension(const base::FilePath& path)
  20     : xw_extension_(0),
  21       created_instance_callback_(NULL),
  22       destroyed_instance_callback_(NULL),
  23       shutdown_callback_(NULL),
  24       handle_msg_callback_(NULL),
  25       handle_sync_msg_callback_(NULL),
  26       initialized_(false),
  27       library_path_(path) {
  28 }
  29
  30 XWalkExternalExtension::~XWalkExternalExtension() {
  31   if (!initialized_)
  32     return;
  33
  34   if (shutdown_callback_)
  35     shutdown_callback_(xw_extension_);
  36   XWalkExternalAdapter::GetInstance()->UnregisterExtension(this);
  37 }
  38
  39 bool XWalkExternalExtension::Initialize() {
  40   if (initialized_)
  41     return true;
  42
  43   std::string error;
  44   base::ScopedNativeLibrary library(
  45       base::LoadNativeLibrary(library_path_, &error));
  46   if (!library.is_valid()) {
  47     LOG(WARNING) << "Error loading extension '"
  48                  << library_path_.AsUTF8Unsafe()
  49                  << "': "
  50                  << error;
  51     return false;
  52   }
  53
  54   XW_Initialize_Func initialize = reinterpret_cast<XW_Initialize_Func>(
  55       library.GetFunctionPointer("XW_Initialize"));
  56   if (!initialize) {
  57     LOG(WARNING) << "Error loading extension '"
  58                  << library_path_.AsUTF8Unsafe() << "': "
  59                  << "couldn't get XW_Initialize function.";
  60     return false;
  61   }
  62
  63   XWalkExternalAdapter* external_adapter = XWalkExternalAdapter::GetInstance();
  64   xw_extension_ = external_adapter->GetNextXWExtension();
  65   external_adapter->RegisterExtension(this);
  66   int ret = initialize(xw_extension_, XWalkExternalAdapter::GetInterface);
  67   if (ret != XW_OK) {
  68     LOG(WARNING) << "Error loading extension '"
  69                  << library_path_.AsUTF8Unsafe() << "': "
  70                  << "XW_Initialize function returned error value.";
  71     return false;
  72   }
  73   library_.Reset(library.Release());
  74   initialized_ = true;
  75   return true;
  76 }
  77
  78 XWalkExtensionInstance* XWalkExternalExtension::CreateInstance() {
  79   XW_Instance xw_instance =
  80       XWalkExternalAdapter::GetInstance()->GetNextXWInstance();
  81   return new XWalkExternalInstance(this, xw_instance);
  82 }
  83
  84 #define RETURN_IF_INITIALIZED(FUNCTION)                          \
  85   if (initialized_) {                                            \
  86     LOG(WARNING) << "Error: can't call " FUNCTION                \
  87                  << " for extension '" << this->name() << "'"    \
  88                  << " after XW_Initialize returned.";            \
  89     return;                                                      \
  90   }
  91
  92 void XWalkExternalExtension::CoreSetExtensionName(const char* name) {
  93   RETURN_IF_INITIALIZED("SetExtensionName from CoreInterface");
  94   set_name(name);
  95 }
  96
  97 void XWalkExternalExtension::CoreSetJavaScriptAPI(const char* js_api) {
  98   RETURN_IF_INITIALIZED("SetJavaScriptAPI from CoreInterface");
  99   set_javascript_api(std::string(js_api));
 100 }
 101
 102 void XWalkExternalExtension::CoreRegisterInstanceCallbacks(
 103     XW_CreatedInstanceCallback created_callback,
 104     XW_DestroyedInstanceCallback destroyed_callback) {
 105   RETURN_IF_INITIALIZED("RegisterInstanceCallbacks from CoreInterface");
 106   created_instance_callback_ = created_callback;
 107   destroyed_instance_callback_ = destroyed_callback;
 108 }
 109
 110 void XWalkExternalExtension::CoreRegisterShutdownCallback(
 111     XW_ShutdownCallback callback) {
 112   RETURN_IF_INITIALIZED("RegisterShutdownCallbacks from CoreInterface");
 113   shutdown_callback_ = callback;
 114 }
 115
 116 void XWalkExternalExtension::MessagingRegister(
 117     XW_HandleMessageCallback callback) {
 118   RETURN_IF_INITIALIZED("Register from MessagingInterface");
 119   handle_msg_callback_ = callback;
 120 }
 121
 122 void XWalkExternalExtension::SyncMessagingRegister(
 123     XW_HandleSyncMessageCallback callback) {
 124   RETURN_IF_INITIALIZED("Register from Internal_SyncMessagingInterface");
 125   handle_sync_msg_callback_ = callback;
 126 }
 127
 128 void XWalkExternalExtension::EntryPointsSetExtraJSEntryPoints(
 129     const char** entry_points) {
 130   RETURN_IF_INITIALIZED("SetExtraJSEntryPoints from EntryPoints");
 131   if (!entry_points)
 132     return;
 133
 134   std::vector<std::string> entries;
 135   for (int i = 0; entry_points[i]; ++i)
 136     entries.push_back(std::string(entry_points[i]));
 137
 138   set_entry_points(entries);
 139 }
 140
 141 void XWalkExternalExtension::RuntimeGetStringVariable(const char* key,
 142     char* value, size_t value_len) {
 143   const base::ValueMap::const_iterator it = runtime_variables_.find(key);
 144   if (it != runtime_variables_.end()) {
 145     std::string json;
 146     base::JSONWriter::Write(it->second, &json);
 147     strncpy(value, json.c_str(), value_len);
 148   } else {
 149     strncpy(value, "", 1);
 150   }
 151 }
 152
 153 }  // namespace extensions
 154 }  // namespace xwalk