#include "xwalk/application/common/constants.h"
#include "xwalk/application/common/manifest_handlers/warp_handler.h"
#include "xwalk/runtime/browser/runtime.h"
-#include "xwalk/runtime/browser/runtime_context.h"
+#include "xwalk/runtime/browser/runtime_ui_delegate.h"
+#include "xwalk/runtime/browser/xwalk_browser_context.h"
#include "xwalk/runtime/browser/xwalk_runner.h"
#if defined(OS_TIZEN)
scoped_ptr<Application> Application::Create(
scoped_refptr<ApplicationData> data,
- RuntimeContext* context) {
+ XWalkBrowserContext* context) {
#if defined(OS_TIZEN)
return make_scoped_ptr<Application>(new ApplicationTizen(data, context));
#else
Application::Application(
scoped_refptr<ApplicationData> data,
- RuntimeContext* runtime_context)
+ XWalkBrowserContext* browser_context)
: data_(data),
render_process_host_(NULL),
web_contents_(NULL),
security_mode_enabled_(false),
- runtime_context_(runtime_context),
+ browser_context_(browser_context),
observer_(NULL),
remote_debugging_enabled_(false),
weak_factory_(this) {
- DCHECK(runtime_context_);
+ DCHECK(browser_context_);
DCHECK(data_.get());
}
#if defined(OS_TIZEN)
if (data_->IsHostedApp()) {
std::string source;
- data_->GetManifest()->GetString(widget_keys::kLaunchLocalPathKey, &source);
- GURL url = GURL(source);
+ GURL url;
+ if (data_->GetManifest()->GetString(
+ widget_keys::kLaunchLocalPathKey, &source)) {
+ url = GURL(source);
+ }
if (url.is_valid() && url.SchemeIsHTTPOrHTTPS())
return url;
GURL Application::GetStartURL<Manifest::TYPE_MANIFEST>() {
if (data_->IsHostedApp()) {
std::string source;
- data_->GetManifest()->GetString(keys::kStartURLKey, &source);
// Not trying to get a relative path for the "fake" application.
- return GURL(source);
+ if (data_->GetManifest()->GetString(keys::kStartURLKey, &source))
+ return GURL(source);
+ return GURL();
}
GURL url = GetAbsoluteURLFromKey(keys::kStartURLKey);
return false;
remote_debugging_enabled_ = launch_params.remote_debugging;
-
- Runtime* runtime = Runtime::Create(
- runtime_context_,
- this, content::SiteInstance::CreateForURL(runtime_context_, url));
+ auto site = content::SiteInstance::CreateForURL(browser_context_, url);
+ Runtime* runtime = Runtime::Create(browser_context_, site);
+ runtime->set_observer(this);
+ runtime->set_remote_debugging_enabled(remote_debugging_enabled_);
+ runtimes_.push_back(runtime);
render_process_host_ = runtime->GetRenderProcessHost();
render_process_host_->AddObserver(this);
web_contents_ = runtime->web_contents();
NativeAppWindow::CreateParams params;
params.net_wm_pid = launch_params.launcher_pid;
params.state = is_wgt ?
- GetWindowShowState<Manifest::TYPE_WIDGET>(launch_params):
+ GetWindowShowState<Manifest::TYPE_WIDGET>(launch_params) :
GetWindowShowState<Manifest::TYPE_MANIFEST>(launch_params);
+ window_show_params_ = params;
+ // Only the first runtime can have a launch screen.
params.splash_screen_path = GetSplashScreenPath();
-
- runtime->AttachWindow(params);
+ runtime->set_ui_delegate(DefaultRuntimeUIDelegate::Create(runtime, params));
+ // We call "Show" after RP is initialized to reduce
+ // the application start up time.
return true;
}
}
void Application::Terminate() {
- std::set<Runtime*> to_be_closed(runtimes_);
- std::for_each(to_be_closed.begin(), to_be_closed.end(),
- std::mem_fun(&Runtime::Close));
+ std::vector<Runtime*> to_be_closed(runtimes_.get());
+ for (Runtime* runtime : to_be_closed)
+ runtime->Close();
}
int Application::GetRenderProcessHostID() const {
return render_process_host_->GetID();
}
-void Application::OnRuntimeAdded(Runtime* runtime) {
- DCHECK(runtime);
+void Application::OnNewRuntimeAdded(Runtime* runtime) {
runtime->set_remote_debugging_enabled(remote_debugging_enabled_);
- runtimes_.insert(runtime);
+ runtime->set_observer(this);
+ runtime->set_ui_delegate(
+ DefaultRuntimeUIDelegate::Create(runtime, window_show_params_));
+ runtime->Show();
+ runtimes_.push_back(runtime);
}
-void Application::OnRuntimeRemoved(Runtime* runtime) {
- DCHECK(runtime);
- runtimes_.erase(runtime);
+void Application::OnRuntimeClosed(Runtime* runtime) {
+ auto found = std::find(runtimes_.begin(), runtimes_.end(), runtime);
+ CHECK(found != runtimes_.end());
+ LOG(INFO) << "Application::OnRuntimeClosed " << runtime;
+ runtimes_.erase(found);
- if (runtimes_.empty()) {
-#if defined(OS_TIZEN_MOBILE)
- runtime->CloseRootWindow();
-#endif
+ if (runtimes_.empty())
base::MessageLoop::current()->PostTask(FROM_HERE,
base::Bind(&Application::NotifyTermination,
weak_factory_.GetWeakPtr()));
- }
}
void Application::RenderProcessExited(RenderProcessHost* host,
observer_->OnApplicationTerminated(this);
}
+void Application::RenderChannelCreated() {
+ CHECK(!runtimes_.empty());
+ runtimes_.front()->Show();
+}
+
bool Application::UseExtension(const std::string& extension_name) const {
// TODO(Bai): Tells whether the application contains the specified extension
return true;
void Application::InitSecurityPolicy() {
// CSP policy takes precedence over WARP.
if (data_->HasCSPDefined())
- security_policy_.reset(new SecurityPolicyCSP(this));
+ security_policy_.reset(new ApplicationSecurityPolicyCSP(this));
else if (data_->manifest_type() == Manifest::TYPE_WIDGET)
- security_policy_.reset(new SecurityPolicyWARP(this));
+ security_policy_.reset(new ApplicationSecurityPolicyWARP(this));
if (security_policy_)
security_policy_->Enforce();