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