};
const char* kEflWebProcess = "/usr/bin/efl_webprocess";
-const char* kLoaderMode = "-lite";
const char* kZoneLibPath = LIB_PATH "/libzone.so.5";
std::mutex prelaunch_mutex;
native_runtime_tv.SetLocaleDir();
}
+void CheckArguments(int argc, char** argv) {
+ for (int i = 1; i < argc; ++i) {
+ if (!strcmp(argv[i], "PayLoad") || !strcmp(argv[i], "PAYLOAD")) {
+ NativeWebRuntimeDelegateTV::GetInstance().SetPayloadData();
+ break;
+ }
+ }
+}
+
} // namespace
-WRTMainDelegateTV::WRTMainDelegateTV() : lazy_initialize_(false) {
+WRTMainDelegateTV::WRTMainDelegateTV() {
SetExecutablePath(kEflWebProcess);
SetNoZygote(false);
}
}
bool WRTMainDelegateTV::CheckPlatformReady(int argc, char** argv) {
- for (int i = 1; i < argc; ++i) {
- if (strcmp(argv[i], kLoaderMode) == 0) {
- lazy_initialize_ = true;
- break;
- }
- }
+ CheckArguments(argc, argv);
return CheckWindowManagerReady();
}
-bool WRTMainDelegateTV::SupportLazyInitialize() {
- return lazy_initialize_;
-}
-
// static
void WRTMainDelegateTV::GroupZygoteProcess(bool is_oom) {
#if defined(ENABLE_PROCESS_GROUP)
}
}
-void WRTMainDelegateTV::LoaderTerminated() {
+void WRTMainDelegateTV::LoaderTerminated(int argc, char** argv) {
reallaunch_mutex.unlock();
monitoring_timer.Stop();
+ CheckArguments(argc, argv);
}
void WRTMainDelegateTV::PrelaunchOnLoader(const std::string& pkg_id) {
bool BasicStartupComplete(int* exit_code) override;
bool CheckPlatformReady(int argc, char** argv) override;
void LoaderCreated() override;
- void LoaderTerminated() override;
+ void LoaderTerminated(int argc, char** argv) override;
void PrelaunchOnLoader(const std::string& pkg_id) override;
bool PreSetup() override;
void PostEarlyInitialization(bool is_running_tests) override;
- bool SupportLazyInitialize() override;
void CreateWorkers();
void CheckCPUUsage();
content::ContentBrowserClient* CreateContentBrowserClient() override;
content::ContentRendererClient* CreateContentRendererClient() override;
-
- bool lazy_initialize_;
};
} // namespace wrt
[](void* data) {
LOG(INFO) << "ContentMain will be initialized in idler.";
auto* content_main = static_cast<WRTContentMain*>(data);
- if (!content_main->main_delegate_->SupportLazyInitialize()) {
- content_main->Initialize();
- content_main->main_delegate_->LoaderCreated();
- }
+ content_main->Initialize();
+ content_main->main_delegate_->LoaderCreated();
return ECORE_CALLBACK_CANCEL;
}, static_cast<Loader*>(user_data)->content_main_);
};
callback.terminate = [](int argc, char** argv, void* user_data) {
LOG(INFO) << "loader terminated";
auto* content_main = static_cast<Loader*>(user_data)->content_main_;
- if (content_main->main_delegate_->SupportLazyInitialize())
- content_main->Initialize();
-
- content_main->main_delegate_->LoaderTerminated();
+ content_main->main_delegate_->LoaderTerminated(argc, argv);
for (int i = 0; i < argc; ++i)
LOG(INFO) << "argv[" << i << "] : " << argv[i];
+
base::CommandLine::ForCurrentProcess()->SetProgram(
base::FilePath(argv[0]));
electron::ElectronCommandLine::InitializeFromCommandLine();
// product specific functions
virtual bool CheckPlatformReady(int argc, char** argv) { return true; }
- virtual bool SupportLazyInitialize() { return false; }
virtual void LoaderCreated() {}
- virtual void LoaderTerminated() {}
+ virtual void LoaderTerminated(int argc, char** argv) {}
virtual void PrelaunchOnLoader(const std::string& pkg_id) {}
virtual bool PreSetup();
#include "electron/shell/common/gin_converters/content_converter.h"
#include "gin/object_template_builder.h"
#include "tizen_src/chromium_impl/tizen/vconf_handle.h"
-#include "tizen_src/ewk/efl_integration/devtools_port_manager.h"
#include "v8/include/v8.h"
#include "wrt/src/base/platform_info.h"
#include "wrt/src/browser/native_web_runtime.h"
TVExtension::~TVExtension() {}
bool TVExtension::NeedUseInspector() const {
- return devtools_http_handler::DevToolsPortManager::GetInstance()
- ->ProcessCompare();
+ auto inspected_appid = VconfHandle("db/rwi/inspected_appid").Str();
+ return inspected_appid == ApplicationData::GetInstance().app_id();
}
bool TVExtension::IsAlwaysReload() const {
void NativeWebRuntimeDelegateTV::Initialize(void* data) {
if (GetProductType() == "IWB")
WRTNativeWindowTV::SetWindowBorderAlpha();
- ApplicationData::GetInstance().Initialize();
- app_id_ = ApplicationData::GetInstance().app_id();
+ auto& app_data = ApplicationData::GetInstance();
+ app_data.Initialize();
+ app_id_ = app_data.app_id();
auto extension_manager = XWalkExtensionManager::GetInstance();
extension_manager->ParseUpgradableExtensions();
extension_manager->RegisterUpgradableExtensions();
initialized_ = true;
}
+void NativeWebRuntimeDelegateTV::EarlyLoadUrlIfHostedApp() {
+ auto& app_data = ApplicationData::GetInstance();
+ if (!app_data.IsHostedApp() || has_payload_data_)
+ return;
+
+ auto start_url = app_data.content_info().src();
+ LOG(INFO) << "start_url : " << start_url;
+ SetDiskCache(true);
+ std::vector<std::string> params = {start_url};
+ NativeWebRuntime::GetInstance().NotifyMessage("loadHostedApp", params);
+}
+
void NativeWebRuntimeDelegateTV::DidInitialized() {
+ EarlyLoadUrlIfHostedApp();
VideoSplashScreen::InitializeVSS();
SetD2dServiceMessageListener();
SubscribePowerState();
void SetProxyInfo(const std::string& proxy_info) {
proxy_info_ = proxy_info;
}
-
+ void SetPayloadData() {
+ has_payload_data_ = true;
+ }
void BuildPrivilegeCache();
std::set<std::string> GetPrivilegeCache();
void ApplyHalfWindow(std::string half_window_option);
void ClearTmpFolder();
+ void EarlyLoadUrlIfHostedApp();
void SetD2dServiceMessageListener();
void SetDiskCache(bool enable);
base::FilePath GetTmgFilePath();
bool locale_dir_binded_ = false;
bool privilege_cahce_init_ = false;
bool power_callback_registered_ = false;
+ bool has_payload_data_ = false;
base::FilePath tmg_file_path_;
std::set<std::string> privileges_cache_;
};