runtime/renderer/injected_bundle.cc

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 #include <Ecore.h>
  18 #include <EWebKit.h>
  19 #include <EWebKit_internal.h>
  20 #include <unistd.h>
  21 #include <v8.h>
  22 #include <dlfcn.h>
  23
  24 #include <memory>
  25 #include <string>
  26
  27 #include "common/application_data.h"
  28 #include "common/locale_manager.h"
  29 #include "common/logger.h"
  30 #include "common/profiler.h"
  31 #include "common/resource_manager.h"
  32 #include "common/string_utils.h"
  33 #include "extensions/renderer/runtime_ipc_client.h"
  34 #include "extensions/renderer/widget_module.h"
  35 #include "extensions/renderer/xwalk_extension_renderer_controller.h"
  36 #include "extensions/renderer/xwalk_module_system.h"
  37
  38 namespace runtime {
  39
  40 class BundleGlobalData {
  41  public:
  42   static BundleGlobalData* GetInstance() {
  43     static BundleGlobalData instance;
  44     return &instance;
  45   }
  46   void PreInitialize() {
  47     if (preInitialized)
  48       return;
  49     preInitialized = true;
  50     locale_manager_.reset(new common::LocaleManager);
  51   }
  52   void Initialize(const std::string& app_id) {
  53     PreInitialize();
  54
  55     auto appdata_manager = common::ApplicationDataManager::GetInstance();
  56     common::ApplicationData* app_data =
  57         appdata_manager->GetApplicationData(app_id);
  58
  59     app_data->LoadManifestData();
  60     // PreInitialized locale_manager_.reset(new common::LocaleManager);
  61     locale_manager_->EnableAutoUpdate(true);
  62     if (app_data->widget_info() != NULL &&
  63         !app_data->widget_info()->default_locale().empty()) {
  64       locale_manager_->SetDefaultLocale(
  65           app_data->widget_info()->default_locale());
  66     }
  67     resource_manager_.reset(new common::ResourceManager(app_data,
  68                             locale_manager_.get()));
  69     resource_manager_->set_base_resource_path(
  70         app_data->application_path());
  71
  72     auto widgetdb = extensions::WidgetPreferenceDB::GetInstance();
  73     widgetdb->Initialize(app_data,
  74                          locale_manager_.get());
  75   }
  76
  77   common::ResourceManager* resource_manager() {
  78     return resource_manager_.get();
  79   }
  80
  81  private:
  82   BundleGlobalData() : preInitialized(false) {}
  83   ~BundleGlobalData() {}
  84   std::unique_ptr<common::ResourceManager> resource_manager_;
  85   std::unique_ptr<common::LocaleManager> locale_manager_;
  86
  87   bool preInitialized;
  88 };
  89
  90 }  //  namespace runtime
  91
  92 extern "C" unsigned int DynamicPluginVersion(void) {
  93   return 1;
  94 }
  95
  96 extern "C" void DynamicSetWidgetInfo(const char* tizen_id) {
  97   SCOPE_PROFILE();
  98   ecore_init();
  99
 100   runtime::BundleGlobalData::GetInstance()->Initialize(tizen_id);
 101   extensions::XWalkExtensionRendererController& controller =
 102     extensions::XWalkExtensionRendererController::GetInstance();
 103   auto appdata_manager = common::ApplicationDataManager::GetInstance();
 104   common::ApplicationData* app_data =
 105     appdata_manager->GetApplicationData(tizen_id);
 106   controller.LoadUserExtensions(app_data->application_path());
 107 }
 108
 109 extern "C" void DynamicPluginStartSession(const char* tizen_id,
 110                                           v8::Handle<v8::Context> context,
 111                                           int routing_handle,
 112                                           const char* base_url) {
 113   SCOPE_PROFILE();
 114
 115   // Initialize context's aligned pointer in embedder data with null
 116   extensions::XWalkModuleSystem::SetModuleSystemInContext(
 117       std::unique_ptr<extensions::XWalkModuleSystem>(), context);
 118
 119   if (base_url == NULL || common::utils::StartsWith(base_url, "http")) {
 120     LOGGER(ERROR) << "External url not allowed plugin loading.";
 121     return;
 122   }
 123
 124   // Initialize RuntimeIPCClient
 125   extensions::RuntimeIPCClient* rc =
 126       extensions::RuntimeIPCClient::GetInstance();
 127   rc->SetRoutingId(context, routing_handle);
 128
 129   extensions::XWalkExtensionRendererController& controller =
 130       extensions::XWalkExtensionRendererController::GetInstance();
 131   controller.DidCreateScriptContext(context);
 132 }
 133
 134 extern "C" void DynamicPluginStopSession(
 135     const char* tizen_id, v8::Handle<v8::Context> context) {
 136   SCOPE_PROFILE();
 137   extensions::XWalkExtensionRendererController& controller =
 138       extensions::XWalkExtensionRendererController::GetInstance();
 139   controller.WillReleaseScriptContext(context);
 140 }
 141
 142 extern "C" void DynamicUrlParsing(
 143     std::string* old_url, std::string* new_url, const char* /*tizen_id*/) {
 144   auto res_manager =
 145       runtime::BundleGlobalData::GetInstance()->resource_manager();
 146   if (res_manager == NULL) {
 147     LOGGER(ERROR) << "Widget Info was not set, Resource Manager is NULL";
 148     *new_url = *old_url;
 149     return;
 150   }
 151   // Check Access control
 152   if (!res_manager->AllowedResource(*old_url)) {
 153     // deined resource
 154     *new_url = "about:blank";
 155     return;
 156   }
 157   // convert to localized path
 158   if (common::utils::StartsWith(*old_url, "file:/") ||
 159       common::utils::StartsWith(*old_url, "app:/")) {
 160     *new_url = res_manager->GetLocalizedPath(*old_url);
 161   } else {
 162     *new_url = *old_url;
 163   }
 164   // check encryption
 165   if (res_manager->IsEncrypted(*new_url)) {
 166     *new_url = res_manager->DecryptResource(*new_url);
 167   }
 168 }
 169
 170 extern "C" void DynamicDatabaseAttach(int /*attach*/) {
 171   // LOGGER(DEBUG) << "InjectedBundle::DynamicDatabaseAttach !!";
 172 }
 173
 174 extern "C" void DynamicOnIPCMessage(const Ewk_IPC_Wrt_Message_Data& data) {
 175   SCOPE_PROFILE();
 176   extensions::XWalkExtensionRendererController& controller =
 177     extensions::XWalkExtensionRendererController::GetInstance();
 178   controller.OnReceivedIPCMessage(&data);
 179 }
 180
 181 extern "C" void DynamicPreloading() {
 182   SCOPE_PROFILE();
 183   runtime::BundleGlobalData::GetInstance()->PreInitialize();
 184   extensions::XWalkExtensionRendererController& controller =
 185     extensions::XWalkExtensionRendererController::GetInstance();
 186   controller.InitializeExtensionClient();
 187 }