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