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 <string>
   8 #include <vector>
   9 #include "base/command_line.h"
  10 #include "base/logging.h"
  11 #include "content/public/browser/render_process_host.h"
  12 #include "xwalk/application/browser/application.h"
  13 #include "xwalk/application/browser/application_service.h"
  14 #include "xwalk/application/browser/application_system.h"
  15 #include "xwalk/extensions/browser/xwalk_extension_service.h"
  16 #include "xwalk/extensions/common/xwalk_extension_switches.h"
  17 #include "xwalk/runtime/browser/application_component.h"
  18 #include "xwalk/runtime/browser/devtools/remote_debugging_server.h"
  19 #include "xwalk/runtime/browser/storage_component.h"
  20 #include "xwalk/runtime/browser/sysapps_component.h"
  21 #include "xwalk/runtime/browser/xwalk_app_extension_bridge.h"
  22 #include "xwalk/runtime/browser/xwalk_browser_context.h"
  23 #include "xwalk/runtime/browser/xwalk_browser_main_parts.h"
  24 #include "xwalk/runtime/browser/xwalk_component.h"
  25 #include "xwalk/runtime/browser/xwalk_content_browser_client.h"
  26 #include "xwalk/runtime/common/xwalk_runtime_features.h"
  27 #include "xwalk/runtime/common/xwalk_switches.h"
  28
  29 #if defined(OS_ANDROID)
  30 #include "xwalk/runtime/browser/xwalk_runner_android.h"
  31 #elif defined(OS_TIZEN)
  32 #include "xwalk/runtime/browser/xwalk_runner_tizen.h"
  33 #endif
  34
  35 namespace xwalk {
  36
  37 namespace {
  38
  39 XWalkRunner* g_xwalk_runner = NULL;
  40
  41 }  // namespace
  42
  43 XWalkRunner::XWalkRunner() {
  44   VLOG(1) << "Creating XWalkRunner object.";
  45   DCHECK(!g_xwalk_runner);
  46   g_xwalk_runner = this;
  47
  48   XWalkRuntimeFeatures::GetInstance()->Initialize(
  49       CommandLine::ForCurrentProcess());
  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   browser_context_.reset(new XWalkBrowserContext);
  73   app_extension_bridge_.reset(new XWalkAppExtensionBridge());
  74
  75   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  76   if (!cmd_line->HasSwitch(switches::kXWalkDisableExtensions))
  77     extension_service_.reset(new extensions::XWalkExtensionService(
  78         app_extension_bridge_.get()));
  79
  80   CreateComponents();
  81   app_extension_bridge_->SetApplicationSystem(app_component_->app_system());
  82 }
  83
  84 void XWalkRunner::PostMainMessageLoopRun() {
  85   DestroyComponents();
  86   extension_service_.reset();
  87   browser_context_.reset();
  88   DisableRemoteDebugging();
  89 }
  90
  91 void XWalkRunner::CreateComponents() {
  92   scoped_ptr<ApplicationComponent> app_component(CreateAppComponent());
  93   // Keep a reference as some code still needs to call
  94   // XWalkRunner::app_system().
  95   app_component_ = app_component.get();
  96   AddComponent(app_component.PassAs<XWalkComponent>());
  97
  98   if (XWalkRuntimeFeatures::isSysAppsEnabled())
  99     AddComponent(CreateSysAppsComponent().PassAs<XWalkComponent>());
 100   if (XWalkRuntimeFeatures::isStorageAPIEnabled())
 101     AddComponent(CreateStorageComponent().PassAs<XWalkComponent>());
 102 }
 103
 104 void XWalkRunner::DestroyComponents() {
 105   // The ScopedVector takes care of deleting all the components. Ensure that
 106   // components are deleted before their dependencies by reversing the order.
 107   std::reverse(components_.begin(), components_.end());
 108   components_.clear();
 109
 110   app_component_ = NULL;
 111 }
 112
 113 void XWalkRunner::AddComponent(scoped_ptr<XWalkComponent> component) {
 114   components_.push_back(component.release());
 115 }
 116
 117 scoped_ptr<ApplicationComponent> XWalkRunner::CreateAppComponent() {
 118   return make_scoped_ptr(new ApplicationComponent(browser_context_.get()));
 119 }
 120
 121 scoped_ptr<SysAppsComponent> XWalkRunner::CreateSysAppsComponent() {
 122   return make_scoped_ptr(new SysAppsComponent());
 123 }
 124
 125 scoped_ptr<StorageComponent> XWalkRunner::CreateStorageComponent() {
 126   return make_scoped_ptr(new StorageComponent());
 127 }
 128
 129 void XWalkRunner::InitializeRuntimeVariablesForExtensions(
 130     const content::RenderProcessHost* host,
 131     base::ValueMap* variables) {
 132   application::Application* app = app_system()->application_service()->
 133       GetApplicationByRenderHostID(host->GetID());
 134
 135   if (app)
 136     (*variables)["app_id"] = new base::StringValue(app->id());
 137 }
 138
 139 void XWalkRunner::OnRenderProcessWillLaunch(content::RenderProcessHost* host) {
 140   if (!extension_service_)
 141     return;
 142
 143   std::vector<extensions::XWalkExtension*> ui_thread_extensions;
 144   std::vector<extensions::XWalkExtension*> extension_thread_extensions;
 145
 146   ScopedVector<XWalkComponent>::iterator it = components_.begin();
 147   for (; it != components_.end(); ++it) {
 148     XWalkComponent* component = *it;
 149     component->CreateUIThreadExtensions(host, &ui_thread_extensions);
 150     component->CreateExtensionThreadExtensions(
 151         host, &extension_thread_extensions);
 152   }
 153
 154   // TODO(cmarcelo): Once functionality is moved to components, remove
 155   // CreateInternalExtensions*() functions from XWalkBrowserMainParts.
 156   XWalkBrowserMainParts* main_parts = content_browser_client_->main_parts();
 157   main_parts->CreateInternalExtensionsForUIThread(
 158       host, &ui_thread_extensions);
 159   main_parts->CreateInternalExtensionsForExtensionThread(
 160       host, &extension_thread_extensions);
 161
 162   scoped_ptr<base::ValueMap> runtime_variables(new base::ValueMap);
 163   InitializeRuntimeVariablesForExtensions(host, runtime_variables.get());
 164   extension_service_->OnRenderProcessWillLaunch(
 165       host, &ui_thread_extensions, &extension_thread_extensions,
 166       runtime_variables.Pass());
 167 }
 168
 169 void XWalkRunner::OnRenderProcessHostGone(content::RenderProcessHost* host) {
 170   if (!extension_service_)
 171     return;
 172   extension_service_->OnRenderProcessDied(host);
 173 }
 174
 175 void XWalkRunner::EnableRemoteDebugging(int port) {
 176   const char* local_ip = "0.0.0.0";
 177   if (port > 0 && port < 65535) {
 178     remote_debugging_server_.reset(
 179         new RemoteDebuggingServer(browser_context(),
 180             local_ip, port, std::string()));
 181   }
 182 }
 183
 184 void XWalkRunner::DisableRemoteDebugging() {
 185   remote_debugging_server_.reset();
 186 }
 187
 188 // static
 189 scoped_ptr<XWalkRunner> XWalkRunner::Create() {
 190   XWalkRunner* runner = NULL;
 191 #if defined(OS_ANDROID)
 192   runner = new XWalkRunnerAndroid;
 193 #elif defined(OS_TIZEN)
 194   runner = new XWalkRunnerTizen;
 195 #else
 196   runner = new XWalkRunner;
 197 #endif
 198   return scoped_ptr<XWalkRunner>(runner);
 199 }
 200
 201 content::ContentBrowserClient* XWalkRunner::GetContentBrowserClient() {
 202   return content_browser_client_.get();
 203 }
 204
 205 }  // namespace xwalk