components/view_manager/view_manager_app.cc

   1 // Copyright 2014 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 "components/view_manager/view_manager_app.h"
   6
   7 #include "base/command_line.h"
   8 #include "components/view_manager/client_connection.h"
   9 #include "components/view_manager/connection_manager.h"
  10 #include "components/view_manager/public/cpp/args.h"
  11 #include "components/view_manager/view_manager_root_connection.h"
  12 #include "components/view_manager/view_manager_root_impl.h"
  13 #include "components/view_manager/view_manager_service_impl.h"
  14 #include "mojo/application/public/cpp/application_connection.h"
  15 #include "mojo/application/public/cpp/application_impl.h"
  16 #include "mojo/application/public/cpp/application_runner.h"
  17 #include "mojo/common/tracing_impl.h"
  18 #include "third_party/mojo/src/mojo/public/c/system/main.h"
  19 #include "ui/events/event_switches.h"
  20 #include "ui/events/platform/platform_event_source.h"
  21 #include "ui/gl/gl_surface.h"
  22 #include "ui/gl/test/gl_surface_test_support.h"
  23
  24 using mojo::ApplicationConnection;
  25 using mojo::ApplicationImpl;
  26 using mojo::Gpu;
  27 using mojo::InterfaceRequest;
  28 using mojo::ViewManagerRoot;
  29 using mojo::ViewManagerService;
  30
  31 namespace view_manager {
  32
  33 ViewManagerApp::ViewManagerApp() : app_impl_(nullptr), is_headless_(false) {
  34 }
  35
  36 ViewManagerApp::~ViewManagerApp() {
  37   if (gpu_state_)
  38     gpu_state_->StopControlThread();
  39 }
  40
  41 void ViewManagerApp::Initialize(ApplicationImpl* app) {
  42   app_impl_ = app;
  43   tracing_.Initialize(app);
  44
  45 #if !defined(OS_ANDROID)
  46   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  47   is_headless_ = command_line->HasSwitch(mojo::kUseHeadlessConfig);
  48   if (!is_headless_) {
  49     event_source_ = ui::PlatformEventSource::CreateDefault();
  50     if (command_line->HasSwitch(mojo::kUseTestConfig))
  51       gfx::GLSurfaceTestSupport::InitializeOneOff();
  52     else
  53       gfx::GLSurface::InitializeOneOff();
  54   }
  55 #endif
  56
  57   if (!gpu_state_.get())
  58     gpu_state_ = new gles2::GpuState;
  59   connection_manager_.reset(new ConnectionManager(this));
  60 }
  61
  62 bool ViewManagerApp::ConfigureIncomingConnection(
  63     ApplicationConnection* connection) {
  64   connection->AddService<ViewManagerRoot>(this);
  65   connection->AddService<Gpu>(this);
  66
  67   return true;
  68 }
  69
  70 void ViewManagerApp::OnNoMoreRootConnections() {
  71   app_impl_->Terminate();
  72 }
  73
  74 ClientConnection* ViewManagerApp::CreateClientConnectionForEmbedAtView(
  75     ConnectionManager* connection_manager,
  76     mojo::InterfaceRequest<mojo::ViewManagerService> service_request,
  77     mojo::ConnectionSpecificId creator_id,
  78     mojo::URLRequestPtr request,
  79     const ViewId& root_id) {
  80   mojo::ViewManagerClientPtr client;
  81   app_impl_->ConnectToService(request.Pass(), &client);
  82
  83   scoped_ptr<ViewManagerServiceImpl> service(
  84       new ViewManagerServiceImpl(connection_manager, creator_id, root_id));
  85   return new DefaultClientConnection(service.Pass(), connection_manager,
  86                                      service_request.Pass(), client.Pass());
  87 }
  88
  89 ClientConnection* ViewManagerApp::CreateClientConnectionForEmbedAtView(
  90     ConnectionManager* connection_manager,
  91     mojo::InterfaceRequest<mojo::ViewManagerService> service_request,
  92     mojo::ConnectionSpecificId creator_id,
  93     const ViewId& root_id,
  94     mojo::ViewManagerClientPtr view_manager_client) {
  95   scoped_ptr<ViewManagerServiceImpl> service(
  96       new ViewManagerServiceImpl(connection_manager, creator_id, root_id));
  97   return new DefaultClientConnection(service.Pass(), connection_manager,
  98                                      service_request.Pass(),
  99                                      view_manager_client.Pass());
 100 }
 101
 102 void ViewManagerApp::Create(ApplicationConnection* connection,
 103                             InterfaceRequest<ViewManagerRoot> request) {
 104   DCHECK(connection_manager_.get());
 105   // TODO(fsamuel): We need to make sure that only the window manager can create
 106   // new roots.
 107   ViewManagerRootImpl* view_manager_root = new ViewManagerRootImpl(
 108       connection_manager_.get(), is_headless_, app_impl_, gpu_state_);
 109
 110   mojo::ViewManagerClientPtr client;
 111   connection->ConnectToService(&client);
 112
 113   // ViewManagerRootConnection manages its own lifetime.
 114   view_manager_root->Init(new ViewManagerRootConnectionImpl(
 115       request.Pass(), make_scoped_ptr(view_manager_root), client.Pass(),
 116       connection_manager_.get()));
 117 }
 118
 119 void ViewManagerApp::Create(
 120     mojo::ApplicationConnection* connection,
 121     mojo::InterfaceRequest<Gpu> request) {
 122   if (!gpu_state_.get())
 123     gpu_state_ = new gles2::GpuState;
 124   new gles2::GpuImpl(request.Pass(), gpu_state_);
 125 }
 126
 127 }  // namespace view_manager