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/extensions/common/xwalk_extension_switches.h"
  16 #include "xwalk/runtime/browser/application_component.h"
  17 #include "xwalk/runtime/browser/runtime_context.h"
  18 #include "xwalk/runtime/browser/storage_component.h"
  19 #include "xwalk/runtime/browser/sysapps_component.h"
  20 #include "xwalk/runtime/browser/xwalk_app_extension_bridge.h"
  21 #include "xwalk/runtime/browser/xwalk_browser_main_parts.h"
  22 #include "xwalk/runtime/browser/xwalk_component.h"
  23 #include "xwalk/runtime/browser/xwalk_content_browser_client.h"
  24 #include "xwalk/runtime/common/xwalk_runtime_features.h"
  25 #include "xwalk/runtime/common/xwalk_switches.h"
  26
  27 #if defined(OS_ANDROID)
  28 #include "xwalk/runtime/browser/xwalk_runner_android.h"
  29 #elif defined(OS_TIZEN)
  30 #include "xwalk/runtime/browser/xwalk_runner_tizen.h"
  31 #endif
  32
  33 namespace xwalk {
  34
  35 namespace {
  36
  37 XWalkRunner* g_xwalk_runner = NULL;
  38
  39 }  // namespace
  40
  41 XWalkRunner::XWalkRunner() {
  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
  49   // Initializing after the g_xwalk_runner is set to ensure
  50   // XWalkRunner::GetInstance() can be used in all sub objects if needed.
  51   content_browser_client_.reset(new XWalkContentBrowserClient(this));
  52 }
  53
  54 XWalkRunner::~XWalkRunner() {
  55   DCHECK(g_xwalk_runner);
  56   g_xwalk_runner = NULL;
  57   VLOG(1) << "Destroying XWalkRunner object.";
  58 }
  59
  60 // static
  61 XWalkRunner* XWalkRunner::GetInstance() {
  62   return g_xwalk_runner;
  63 }
  64
  65 application::ApplicationSystem* XWalkRunner::app_system() {
  66   return app_component_ ? app_component_->app_system() : NULL;
  67 }
  68
  69 void XWalkRunner::PreMainMessageLoopRun() {
  70   runtime_context_.reset(new RuntimeContext);
  71   app_extension_bridge_.reset(new XWalkAppExtensionBridge());
  72
  73   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  74   if (!cmd_line->HasSwitch(switches::kXWalkDisableExtensions))
  75     extension_service_.reset(new extensions::XWalkExtensionService(
  76         app_extension_bridge_.get()));
  77
  78   CreateComponents();
  79   app_extension_bridge_->SetApplicationSystem(app_component_->app_system());
  80 }
  81
  82 void XWalkRunner::PostMainMessageLoopRun() {
  83   DestroyComponents();
  84   extension_service_.reset();
  85   runtime_context_.reset();
  86 }
  87
  88 void XWalkRunner::CreateComponents() {
  89   scoped_ptr<ApplicationComponent> app_component(CreateAppComponent());
  90   // Keep a reference as some code still needs to call
  91   // XWalkRunner::app_system().
  92   app_component_ = app_component.get();
  93   AddComponent(app_component.PassAs<XWalkComponent>());
  94
  95   if (XWalkRuntimeFeatures::isSysAppsEnabled())
  96     AddComponent(CreateSysAppsComponent().PassAs<XWalkComponent>());
  97   if (XWalkRuntimeFeatures::isStorageAPIEnabled())
  98     AddComponent(CreateStorageComponent().PassAs<XWalkComponent>());
  99 }
 100
 101 void XWalkRunner::DestroyComponents() {
 102   // The ScopedVector takes care of deleting all the components. Ensure that
 103   // components are deleted before their dependencies by reversing the order.
 104   std::reverse(components_.begin(), components_.end());
 105   components_.clear();
 106
 107   app_component_ = NULL;
 108 }
 109
 110 void XWalkRunner::AddComponent(scoped_ptr<XWalkComponent> component) {
 111   components_.push_back(component.release());
 112 }
 113
 114 scoped_ptr<ApplicationComponent> XWalkRunner::CreateAppComponent() {
 115   return make_scoped_ptr(new ApplicationComponent(runtime_context_.get()));
 116 }
 117
 118 scoped_ptr<SysAppsComponent> XWalkRunner::CreateSysAppsComponent() {
 119   return make_scoped_ptr(new SysAppsComponent());
 120 }
 121
 122 scoped_ptr<StorageComponent> XWalkRunner::CreateStorageComponent() {
 123   return make_scoped_ptr(new StorageComponent());
 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   scoped_ptr<base::ValueMap> runtime_variables(new base::ValueMap);
 160   InitializeRuntimeVariablesForExtensions(host, runtime_variables.get());
 161   extension_service_->OnRenderProcessWillLaunch(
 162       host, &ui_thread_extensions, &extension_thread_extensions,
 163       runtime_variables.Pass());
 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