src/mojo/shell/context.cc

   1 // Copyright 2013 The Chromium Authors. 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 "mojo/shell/context.h"
   6
   7 #include <vector>
   8
   9 #include "base/command_line.h"
  10 #include "base/lazy_instance.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/strings/string_split.h"
  14 #include "build/build_config.h"
  15 #include "gpu/command_buffer/service/mailbox_manager.h"
  16 #include "mojo/application_manager/application_loader.h"
  17 #include "mojo/application_manager/application_manager.h"
  18 #include "mojo/application_manager/background_shell_application_loader.h"
  19 #include "mojo/embedder/embedder.h"
  20 #include "mojo/embedder/simple_platform_support.h"
  21 #include "mojo/public/cpp/application/application_connection.h"
  22 #include "mojo/public/cpp/application/application_delegate.h"
  23 #include "mojo/public/cpp/application/application_impl.h"
  24 #include "mojo/shell/dynamic_application_loader.h"
  25 #include "mojo/shell/in_process_dynamic_service_runner.h"
  26 #include "mojo/shell/out_of_process_dynamic_service_runner.h"
  27 #include "mojo/shell/switches.h"
  28 #include "mojo/shell/ui_application_loader_android.h"
  29 #include "mojo/spy/spy.h"
  30
  31 #if defined(OS_LINUX)
  32 #include "mojo/shell/dbus_application_loader_linux.h"
  33 #endif  // defined(OS_LINUX)
  34
  35 #if defined(OS_ANDROID)
  36 #include "mojo/services/native_viewport/gpu_impl.h"
  37 #include "mojo/services/native_viewport/native_viewport_impl.h"
  38 #include "mojo/shell/network_application_loader.h"
  39 #include "ui/gl/gl_share_group.h"
  40 #endif  // defined(OS_ANDROID)
  41
  42 namespace mojo {
  43 namespace shell {
  44 namespace {
  45
  46 // These mojo: URLs are loaded directly from the local filesystem. They
  47 // correspond to shared libraries bundled alongside the mojo_shell.
  48 const char* kLocalMojoURLs[] = {
  49   "mojo:mojo_network_service",
  50 };
  51
  52 // Used to ensure we only init once.
  53 class Setup {
  54  public:
  55   Setup() {
  56     embedder::Init(scoped_ptr<mojo::embedder::PlatformSupport>(
  57         new mojo::embedder::SimplePlatformSupport()));
  58   }
  59
  60   ~Setup() {
  61   }
  62
  63  private:
  64   DISALLOW_COPY_AND_ASSIGN(Setup);
  65 };
  66
  67 static base::LazyInstance<Setup>::Leaky setup = LAZY_INSTANCE_INITIALIZER;
  68
  69 void InitContentHandlers(DynamicApplicationLoader* loader,
  70                          base::CommandLine* command_line) {
  71   // Default content handlers.
  72   loader->RegisterContentHandler("image/png", GURL("mojo://mojo_png_viewer/"));
  73   loader->RegisterContentHandler("text/html", GURL("mojo://mojo_html_viewer/"));
  74
  75   // Command-line-specified content handlers.
  76   std::string handlers_spec = command_line->GetSwitchValueASCII(
  77       switches::kContentHandlers);
  78   if (handlers_spec.empty())
  79     return;
  80
  81   std::vector<std::string> parts;
  82   base::SplitString(handlers_spec, ',', &parts);
  83   if (parts.size() % 2 != 0) {
  84     LOG(ERROR) << "Invalid value for switch " << switches::kContentHandlers
  85                << ": must be a comma-separated list of mimetype/url pairs.";
  86     return;
  87   }
  88
  89   for (size_t i = 0; i < parts.size(); i += 2) {
  90     GURL url(parts[i + 1]);
  91     if (!url.is_valid()) {
  92       LOG(ERROR) << "Invalid value for switch " << switches::kContentHandlers
  93                  << ": '" << parts[i + 1] << "' is not a valid URL.";
  94       return;
  95     }
  96     loader->RegisterContentHandler(parts[i], url);
  97   }
  98 }
  99
 100 class EmptyServiceProvider : public InterfaceImpl<ServiceProvider> {
 101  private:
 102   virtual void ConnectToService(const mojo::String& service_name,
 103                                 ScopedMessagePipeHandle client_handle)
 104       MOJO_OVERRIDE {
 105   }
 106 };
 107
 108 }  // namespace
 109
 110 #if defined(OS_ANDROID)
 111 class Context::NativeViewportApplicationLoader
 112     : public ApplicationLoader,
 113       public ApplicationDelegate,
 114       public InterfaceFactory<NativeViewport>,
 115       public InterfaceFactory<Gpu> {
 116  public:
 117   NativeViewportApplicationLoader()
 118       : share_group_(new gfx::GLShareGroup),
 119         mailbox_manager_(new gpu::gles2::MailboxManager) {}
 120   virtual ~NativeViewportApplicationLoader() {}
 121
 122  private:
 123   // ApplicationLoader implementation.
 124   virtual void Load(ApplicationManager* manager,
 125                     const GURL& url,
 126                     scoped_refptr<LoadCallbacks> callbacks) OVERRIDE {
 127     ScopedMessagePipeHandle shell_handle = callbacks->RegisterApplication();
 128     if (shell_handle.is_valid())
 129       app_.reset(new ApplicationImpl(this, shell_handle.Pass()));
 130   }
 131
 132   virtual void OnApplicationError(ApplicationManager* manager,
 133                                   const GURL& url) OVERRIDE {}
 134
 135   // ApplicationDelegate implementation.
 136   virtual bool ConfigureIncomingConnection(
 137       mojo::ApplicationConnection* connection) OVERRIDE {
 138     connection->AddService<NativeViewport>(this);
 139     connection->AddService<Gpu>(this);
 140     return true;
 141   }
 142
 143   // InterfaceFactory<NativeViewport> implementation.
 144   virtual void Create(ApplicationConnection* connection,
 145                       InterfaceRequest<NativeViewport> request) OVERRIDE {
 146     BindToRequest(new NativeViewportImpl(app_.get(), false), &request);
 147   }
 148
 149   // InterfaceFactory<Gpu> implementation.
 150   virtual void Create(ApplicationConnection* connection,
 151                       InterfaceRequest<Gpu> request) OVERRIDE {
 152     BindToRequest(new GpuImpl(share_group_.get(), mailbox_manager_.get()),
 153                   &request);
 154   }
 155
 156   scoped_refptr<gfx::GLShareGroup> share_group_;
 157   scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
 158   scoped_ptr<ApplicationImpl> app_;
 159   DISALLOW_COPY_AND_ASSIGN(NativeViewportApplicationLoader);
 160 };
 161 #endif
 162
 163 Context::Context() {
 164   DCHECK(!base::MessageLoop::current());
 165 }
 166
 167 Context::~Context() {
 168   DCHECK(!base::MessageLoop::current());
 169 }
 170
 171 void Context::Init() {
 172   application_manager_.set_delegate(this);
 173   setup.Get();
 174   task_runners_.reset(
 175       new TaskRunners(base::MessageLoop::current()->message_loop_proxy()));
 176
 177   for (size_t i = 0; i < arraysize(kLocalMojoURLs); ++i)
 178     mojo_url_resolver_.AddLocalFileMapping(GURL(kLocalMojoURLs[i]));
 179
 180   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 181   scoped_ptr<DynamicServiceRunnerFactory> runner_factory;
 182   if (command_line->HasSwitch(switches::kEnableMultiprocess))
 183     runner_factory.reset(new OutOfProcessDynamicServiceRunnerFactory());
 184   else
 185     runner_factory.reset(new InProcessDynamicServiceRunnerFactory());
 186
 187   DynamicApplicationLoader* dynamic_application_loader =
 188       new DynamicApplicationLoader(this, runner_factory.Pass());
 189   InitContentHandlers(dynamic_application_loader, command_line);
 190   application_manager_.set_default_loader(
 191       scoped_ptr<ApplicationLoader>(dynamic_application_loader));
 192
 193   // The native viewport service synchronously waits for certain messages. If we
 194   // don't run it on its own thread we can easily deadlock. Long term native
 195   // viewport should run its own process so that this isn't an issue.
 196 #if defined(OS_ANDROID)
 197   application_manager_.SetLoaderForURL(
 198       scoped_ptr<ApplicationLoader>(new UIApplicationLoader(
 199           scoped_ptr<ApplicationLoader>(new NativeViewportApplicationLoader()),
 200           this)),
 201       GURL("mojo:mojo_native_viewport_service"));
 202 #endif
 203
 204 #if defined(OS_LINUX)
 205   application_manager_.SetLoaderForScheme(
 206       scoped_ptr<ApplicationLoader>(new DBusApplicationLoader(this)), "dbus");
 207 #endif  // defined(OS_LINUX)
 208
 209   if (command_line->HasSwitch(switches::kSpy)) {
 210     spy_.reset(
 211         new mojo::Spy(&application_manager_,
 212                       command_line->GetSwitchValueASCII(switches::kSpy)));
 213   }
 214
 215 #if defined(OS_ANDROID)
 216   // On android, the network service is bundled with the shell because the
 217   // network stack depends on the android runtime.
 218   {
 219     scoped_ptr<BackgroundShellApplicationLoader> loader(
 220         new BackgroundShellApplicationLoader(
 221             scoped_ptr<ApplicationLoader>(new NetworkApplicationLoader()),
 222             "network_service",
 223             base::MessageLoop::TYPE_IO));
 224     application_manager_.SetLoaderForURL(loader.PassAs<ApplicationLoader>(),
 225                                          GURL("mojo:mojo_network_service"));
 226   }
 227 #endif
 228 }
 229
 230 void Context::OnApplicationError(const GURL& gurl) {
 231   if (app_urls_.find(gurl) != app_urls_.end()) {
 232     app_urls_.erase(gurl);
 233     if (app_urls_.empty() && base::MessageLoop::current()->is_running())
 234       base::MessageLoop::current()->Quit();
 235   }
 236 }
 237
 238 void Context::Run(const GURL& url) {
 239   EmptyServiceProvider* sp = new EmptyServiceProvider;
 240   ServiceProviderPtr spp;
 241   BindToProxy(sp, &spp);
 242
 243   app_urls_.insert(url);
 244   application_manager_.ConnectToApplication(url, GURL(), spp.Pass());
 245 }
 246
 247 ScopedMessagePipeHandle Context::ConnectToServiceByName(
 248     const GURL& application_url,
 249     const std::string& service_name) {
 250   app_urls_.insert(application_url);
 251   return application_manager_.ConnectToServiceByName(
 252       application_url, service_name).Pass();
 253 }
 254
 255 }  // namespace shell
 256 }  // namespace mojo