src/xwalk/runtime/browser/xwalk_runner.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/runtime/browser/xwalk_runner.h"
   6
   7 #include <vector>
   8 #include "base/command_line.h"
   9 #include "base/logging.h"
  10 #include "content/public/browser/render_process_host.h"
  11 #include "xwalk/application/browser/application.h"
  12 #include "xwalk/application/browser/application_service.h"
  13 #include "xwalk/application/browser/application_system.h"
  14 #include "xwalk/extensions/browser/xwalk_extension_service.h"
  15 #include "xwalk/runtime/browser/application_component.h"
  16 #include "xwalk/runtime/browser/runtime_context.h"
  17 #include "xwalk/runtime/browser/sysapps_component.h"
  18 #include "xwalk/runtime/browser/xwalk_app_extension_bridge.h"
  19 #include "xwalk/runtime/browser/xwalk_browser_main_parts.h"
  20 #include "xwalk/runtime/browser/xwalk_component.h"
  21 #include "xwalk/runtime/browser/xwalk_content_browser_client.h"
  22 #include "xwalk/runtime/common/xwalk_runtime_features.h"
  23 #include "xwalk/runtime/common/xwalk_switches.h"
  24
  25 #if defined(OS_ANDROID)
  26 #include "xwalk/runtime/browser/xwalk_runner_android.h"
  27 #elif defined(OS_TIZEN)
  28 #include "xwalk/runtime/browser/xwalk_runner_tizen.h"
  29 #endif
  30
  31 namespace xwalk {
  32
  33 namespace {
  34
  35 const char kDefaultLocale[] = "en-US";
  36 XWalkRunner* g_xwalk_runner = NULL;
  37
  38 }  // namespace
  39
  40 XWalkRunner::XWalkRunner()
  41     : is_running_as_service_(false) {
  42   VLOG(1) << "Creating XWalkRunner object.";
  43   DCHECK(!g_xwalk_runner);
  44   g_xwalk_runner = this;
  45
  46   XWalkRuntimeFeatures::GetInstance()->Initialize(
  47       CommandLine::ForCurrentProcess());
  48   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  49   is_running_as_service_ = cmd_line->HasSwitch(switches::kXWalkRunAsService);
  50
  51   // Initializing after the g_xwalk_runner is set to ensure
  52   // XWalkRunner::GetInstance() can be used in all sub objects if needed.
  53   content_browser_client_.reset(new XWalkContentBrowserClient(this));
  54 }
  55
  56 XWalkRunner::~XWalkRunner() {
  57   DCHECK(g_xwalk_runner);
  58   g_xwalk_runner = NULL;
  59   VLOG(1) << "Destroying XWalkRunner object.";
  60 }
  61
  62 // static
  63 XWalkRunner* XWalkRunner::GetInstance() {
  64   return g_xwalk_runner;
  65 }
  66
  67 application::ApplicationSystem* XWalkRunner::app_system() {
  68   return app_component_ ? app_component_->app_system() : NULL;
  69 }
  70
  71 void XWalkRunner::PreMainMessageLoopRun() {
  72   runtime_context_.reset(new RuntimeContext);
  73   app_extension_bridge_.reset(new XWalkAppExtensionBridge());
  74   // FIXME(cmarcelo): Remove this check once we remove the --uninstall
  75   // command line.
  76   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  77   if (!cmd_line->HasSwitch(switches::kUninstall))
  78     extension_service_.reset(new extensions::XWalkExtensionService(
  79         app_extension_bridge_.get()));
  80   CreateComponents();
  81   app_extension_bridge_->SetApplicationSystem(app_component_->app_system());
  82 }
  83
  84 void XWalkRunner::PostMainMessageLoopRun() {
  85   DestroyComponents();
  86   extension_service_.reset();
  87   runtime_context_.reset();
  88 }
  89
  90 std::string XWalkRunner::GetLocale() const {
  91   return kDefaultLocale;
  92 }
  93
  94 void XWalkRunner::CreateComponents() {
  95   scoped_ptr<ApplicationComponent> app_component(CreateAppComponent());
  96   // Keep a reference as some code still needs to call
  97   // XWalkRunner::app_system().
  98   app_component_ = app_component.get();
  99   AddComponent(app_component.PassAs<XWalkComponent>());
 100
 101   if (XWalkRuntimeFeatures::isSysAppsEnabled())
 102     AddComponent(CreateSysAppsComponent().PassAs<XWalkComponent>());
 103 }
 104
 105 void XWalkRunner::DestroyComponents() {
 106   // The ScopedVector takes care of deleting all the components. Ensure that
 107   // components are deleted before their dependencies by reversing the order.
 108   std::reverse(components_.begin(), components_.end());
 109   components_.clear();
 110
 111   app_component_ = NULL;
 112 }
 113
 114 void XWalkRunner::AddComponent(scoped_ptr<XWalkComponent> component) {
 115   components_.push_back(component.release());
 116 }
 117
 118 scoped_ptr<ApplicationComponent> XWalkRunner::CreateAppComponent() {
 119   return make_scoped_ptr(new ApplicationComponent(runtime_context_.get()));
 120 }
 121
 122 scoped_ptr<SysAppsComponent> XWalkRunner::CreateSysAppsComponent() {
 123   return make_scoped_ptr(new SysAppsComponent());
 124 }
 125
 126 void XWalkRunner::InitializeRuntimeVariablesForExtensions(
 127     const content::RenderProcessHost* host,
 128     base::ValueMap& variables) {
 129   application::Application* app = app_system()->application_service()->
 130       GetApplicationByRenderHostID(host->GetID());
 131
 132   if (app)
 133     variables["app_id"] = base::Value::CreateStringValue(app->id());
 134 }
 135
 136 void XWalkRunner::OnRenderProcessWillLaunch(content::RenderProcessHost* host) {
 137   if (!extension_service_)
 138     return;
 139
 140   std::vector<extensions::XWalkExtension*> ui_thread_extensions;
 141   std::vector<extensions::XWalkExtension*> extension_thread_extensions;
 142
 143   ScopedVector<XWalkComponent>::iterator it = components_.begin();
 144   for (; it != components_.end(); ++it) {
 145     XWalkComponent* component = *it;
 146     component->CreateUIThreadExtensions(host, &ui_thread_extensions);
 147     component->CreateExtensionThreadExtensions(
 148         host, &extension_thread_extensions);
 149   }
 150
 151   // TODO(cmarcelo): Once functionality is moved to components, remove
 152   // CreateInternalExtensions*() functions from XWalkBrowserMainParts.
 153   XWalkBrowserMainParts* main_parts = content_browser_client_->main_parts();
 154   main_parts->CreateInternalExtensionsForUIThread(
 155       host, &ui_thread_extensions);
 156   main_parts->CreateInternalExtensionsForExtensionThread(
 157       host, &extension_thread_extensions);
 158
 159   base::ValueMap runtime_variables;
 160   InitializeRuntimeVariablesForExtensions(host, runtime_variables);
 161   extension_service_->OnRenderProcessWillLaunch(
 162       host, &ui_thread_extensions, &extension_thread_extensions,
 163       runtime_variables);
 164 }
 165
 166 void XWalkRunner::OnRenderProcessHostGone(content::RenderProcessHost* host) {
 167   if (!extension_service_)
 168     return;
 169   extension_service_->OnRenderProcessDied(host);
 170 }
 171
 172 // static
 173 scoped_ptr<XWalkRunner> XWalkRunner::Create() {
 174   XWalkRunner* runner = NULL;
 175 #if defined(OS_ANDROID)
 176   runner = new XWalkRunnerAndroid;
 177 #elif defined(OS_TIZEN)
 178   runner = new XWalkRunnerTizen;
 179 #else
 180   runner = new XWalkRunner;
 181 #endif
 182   return scoped_ptr<XWalkRunner>(runner);
 183 }
 184
 185 content::ContentBrowserClient* XWalkRunner::GetContentBrowserClient() {
 186   return content_browser_client_.get();
 187 }
 188
 189 }  // namespace xwalk