ui/ozone/demo/ozone_demo.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 "base/at_exit.h"
   6 #include "base/command_line.h"
   7 #include "base/memory/scoped_vector.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/run_loop.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "ui/display/types/display_snapshot.h"
  12 #include "ui/display/types/native_display_delegate.h"
  13 #include "ui/display/types/native_display_observer.h"
  14 #include "ui/events/event.h"
  15 #include "ui/events/keycodes/dom/dom_code.h"
  16 #include "ui/events/ozone/layout/keyboard_layout_engine.h"
  17 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
  18 #include "ui/gfx/geometry/rect.h"
  19 #include "ui/gfx/geometry/size.h"
  20 #include "ui/gl/gl_surface.h"
  21 #include "ui/ozone/demo/gl_renderer.h"
  22 #include "ui/ozone/demo/software_renderer.h"
  23 #include "ui/ozone/demo/surfaceless_gl_renderer.h"
  24 #include "ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h"
  25 #include "ui/ozone/public/ozone_gpu_test_helper.h"
  26 #include "ui/ozone/public/ozone_platform.h"
  27 #include "ui/ozone/public/ozone_switches.h"
  28 #include "ui/platform_window/platform_window.h"
  29 #include "ui/platform_window/platform_window_delegate.h"
  30
  31 const int kTestWindowWidth = 800;
  32 const int kTestWindowHeight = 600;
  33
  34 const char kDisableGpu[] = "disable-gpu";
  35
  36 const char kWindowSize[] = "window-size";
  37
  38 class DemoWindow;
  39
  40 class RendererFactory {
  41  public:
  42   enum RendererType {
  43     GL,
  44     SURFACELESS_GL,
  45     SOFTWARE,
  46   };
  47
  48   RendererFactory();
  49   ~RendererFactory();
  50
  51   bool Initialize();
  52   scoped_ptr<ui::Renderer> CreateRenderer(gfx::AcceleratedWidget widget,
  53                                           const gfx::Size& size);
  54
  55  private:
  56   RendererType type_ = SOFTWARE;
  57
  58   // Helper for applications that do GL on main thread.
  59   ui::OzoneGpuTestHelper gpu_helper_;
  60
  61   // Used by the surfaceless renderers to allocate buffers.
  62   ui::GpuMemoryBufferFactoryOzoneNativeBuffer buffer_factory_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(RendererFactory);
  65 };
  66
  67 class WindowManager : public ui::NativeDisplayObserver {
  68  public:
  69   WindowManager(const base::Closure& quit_closure);
  70   ~WindowManager() override;
  71
  72   void Quit();
  73
  74   void AddWindow(DemoWindow* window);
  75   void RemoveWindow(DemoWindow* window);
  76
  77  private:
  78   void OnDisplaysAquired(const std::vector<ui::DisplaySnapshot*>& displays);
  79   void OnDisplayConfigured(const gfx::Rect& bounds, bool success);
  80
  81   // ui::NativeDisplayDelegate:
  82   void OnConfigurationChanged() override;
  83
  84   scoped_ptr<ui::NativeDisplayDelegate> delegate_;
  85   base::Closure quit_closure_;
  86   RendererFactory renderer_factory_;
  87   ScopedVector<DemoWindow> windows_;
  88
  89   // Flags used to keep track of the current state of display configuration.
  90   //
  91   // True if configuring the displays. In this case a new display configuration
  92   // isn't started.
  93   bool is_configuring_ = false;
  94
  95   // If |is_configuring_| is true and another display configuration event
  96   // happens, the event is deferred. This is set to true and a display
  97   // configuration will be scheduled after the current one finishes.
  98   bool should_configure_ = false;
  99
 100   DISALLOW_COPY_AND_ASSIGN(WindowManager);
 101 };
 102
 103 class DemoWindow : public ui::PlatformWindowDelegate {
 104  public:
 105   DemoWindow(WindowManager* window_manager,
 106              RendererFactory* renderer_factory,
 107              const gfx::Rect& bounds)
 108       : window_manager_(window_manager),
 109         renderer_factory_(renderer_factory),
 110         weak_ptr_factory_(this) {
 111     platform_window_ =
 112         ui::OzonePlatform::GetInstance()->CreatePlatformWindow(this, bounds);
 113   }
 114   ~DemoWindow() override {}
 115
 116   gfx::AcceleratedWidget GetAcceleratedWidget() {
 117     // TODO(spang): We should start rendering asynchronously.
 118     DCHECK_NE(widget_, gfx::kNullAcceleratedWidget)
 119         << "Widget not available synchronously";
 120     return widget_;
 121   }
 122
 123   gfx::Size GetSize() { return platform_window_->GetBounds().size(); }
 124
 125   void Start() {
 126     base::ThreadTaskRunnerHandle::Get()->PostTask(
 127         FROM_HERE,
 128         base::Bind(&DemoWindow::StartOnGpu, weak_ptr_factory_.GetWeakPtr()));
 129   }
 130
 131   void Quit() {
 132     window_manager_->Quit();
 133   }
 134
 135   // PlatformWindowDelegate:
 136   void OnBoundsChanged(const gfx::Rect& new_bounds) override {}
 137   void OnDamageRect(const gfx::Rect& damaged_region) override {}
 138   void DispatchEvent(ui::Event* event) override {
 139     if (event->IsKeyEvent() &&
 140         static_cast<ui::KeyEvent*>(event)->code() == ui::DomCode::KEY_Q)
 141       Quit();
 142   }
 143   void OnCloseRequest() override { Quit(); }
 144   void OnClosed() override {}
 145   void OnWindowStateChanged(ui::PlatformWindowState new_state) override {}
 146   void OnLostCapture() override {}
 147   void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget,
 148                                     float device_pixel_ratio) override {
 149     DCHECK_NE(widget, gfx::kNullAcceleratedWidget);
 150     widget_ = widget;
 151   }
 152   void OnActivationChanged(bool active) override {}
 153
 154  private:
 155   // Since we pretend to have a GPU process, we should also pretend to
 156   // initialize the GPU resources via a posted task.
 157   void StartOnGpu() {
 158     renderer_ =
 159         renderer_factory_->CreateRenderer(GetAcceleratedWidget(), GetSize());
 160     renderer_->Initialize();
 161   }
 162
 163   WindowManager* window_manager_;      // Not owned.
 164   RendererFactory* renderer_factory_;  // Not owned.
 165
 166   scoped_ptr<ui::Renderer> renderer_;
 167
 168   // Window-related state.
 169   scoped_ptr<ui::PlatformWindow> platform_window_;
 170   gfx::AcceleratedWidget widget_ = gfx::kNullAcceleratedWidget;
 171
 172   base::WeakPtrFactory<DemoWindow> weak_ptr_factory_;
 173
 174   DISALLOW_COPY_AND_ASSIGN(DemoWindow);
 175 };
 176
 177 ///////////////////////////////////////////////////////////////////////////////
 178 // RendererFactory implementation:
 179
 180 RendererFactory::RendererFactory() {
 181 }
 182
 183 RendererFactory::~RendererFactory() {
 184 }
 185
 186 bool RendererFactory::Initialize() {
 187   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 188   if (!command_line->HasSwitch(kDisableGpu) &&
 189       gfx::GLSurface::InitializeOneOff() &&
 190       gpu_helper_.Initialize(base::ThreadTaskRunnerHandle::Get(),
 191                              base::ThreadTaskRunnerHandle::Get())) {
 192     if (command_line->HasSwitch(switches::kOzoneUseSurfaceless)) {
 193       type_ = SURFACELESS_GL;
 194     } else {
 195       type_ = GL;
 196     }
 197   } else {
 198     type_ = SOFTWARE;
 199   }
 200
 201   return true;
 202 }
 203
 204 scoped_ptr<ui::Renderer> RendererFactory::CreateRenderer(
 205     gfx::AcceleratedWidget widget,
 206     const gfx::Size& size) {
 207   switch (type_) {
 208     case GL:
 209       return make_scoped_ptr(new ui::GlRenderer(widget, size));
 210     case SURFACELESS_GL:
 211       return make_scoped_ptr(
 212           new ui::SurfacelessGlRenderer(widget, size, &buffer_factory_));
 213     case SOFTWARE:
 214       return make_scoped_ptr(new ui::SoftwareRenderer(widget, size));
 215   }
 216
 217   return nullptr;
 218 }
 219
 220 ///////////////////////////////////////////////////////////////////////////////
 221 // WindowManager implementation:
 222
 223 WindowManager::WindowManager(const base::Closure& quit_closure)
 224     : delegate_(
 225           ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate()),
 226       quit_closure_(quit_closure) {
 227   if (!renderer_factory_.Initialize())
 228     LOG(FATAL) << "Failed to initialize renderer factory";
 229
 230   if (delegate_) {
 231     delegate_->AddObserver(this);
 232     delegate_->Initialize();
 233     OnConfigurationChanged();
 234   } else {
 235     LOG(WARNING) << "No display delegate; falling back to test window";
 236     int width = kTestWindowWidth;
 237     int height = kTestWindowHeight;
 238     sscanf(base::CommandLine::ForCurrentProcess()
 239                ->GetSwitchValueASCII(kWindowSize)
 240                .c_str(),
 241            "%dx%d", &width, &height);
 242
 243     DemoWindow* window = new DemoWindow(this, &renderer_factory_,
 244                                         gfx::Rect(gfx::Size(width, height)));
 245     window->Start();
 246   }
 247 }
 248
 249 WindowManager::~WindowManager() {
 250   if (delegate_)
 251     delegate_->RemoveObserver(this);
 252 }
 253
 254 void WindowManager::Quit() {
 255   quit_closure_.Run();
 256 }
 257
 258 void WindowManager::OnConfigurationChanged() {
 259   if (is_configuring_) {
 260     should_configure_ = true;
 261     return;
 262   }
 263
 264   is_configuring_ = true;
 265   delegate_->GrabServer();
 266   delegate_->GetDisplays(
 267       base::Bind(&WindowManager::OnDisplaysAquired, base::Unretained(this)));
 268 }
 269
 270 void WindowManager::OnDisplaysAquired(
 271     const std::vector<ui::DisplaySnapshot*>& displays) {
 272   windows_.clear();
 273
 274   gfx::Point origin;
 275   for (auto display : displays) {
 276     if (!display->native_mode()) {
 277       LOG(ERROR) << "Display " << display->display_id()
 278                  << " doesn't have a native mode";
 279       continue;
 280     }
 281
 282     delegate_->Configure(
 283         *display, display->native_mode(), origin,
 284         base::Bind(&WindowManager::OnDisplayConfigured, base::Unretained(this),
 285                    gfx::Rect(origin, display->native_mode()->size())));
 286     origin.Offset(display->native_mode()->size().width(), 0);
 287   }
 288   delegate_->UngrabServer();
 289   is_configuring_ = false;
 290
 291   if (should_configure_) {
 292     should_configure_ = false;
 293     base::ThreadTaskRunnerHandle::Get()->PostTask(
 294         FROM_HERE, base::Bind(&WindowManager::OnConfigurationChanged,
 295                               base::Unretained(this)));
 296   }
 297 }
 298
 299 void WindowManager::OnDisplayConfigured(const gfx::Rect& bounds, bool success) {
 300   if (success) {
 301     scoped_ptr<DemoWindow> window(
 302         new DemoWindow(this, &renderer_factory_, bounds));
 303     window->Start();
 304     windows_.push_back(window.Pass());
 305   } else {
 306     LOG(ERROR) << "Failed to configure display at " << bounds.ToString();
 307   }
 308 }
 309
 310 int main(int argc, char** argv) {
 311   base::CommandLine::Init(argc, argv);
 312   base::AtExitManager exit_manager;
 313
 314   // Initialize logging so we can enable VLOG messages.
 315   logging::LoggingSettings settings;
 316   logging::InitLogging(settings);
 317
 318   // Build UI thread message loop. This is used by platform
 319   // implementations for event polling & running background tasks.
 320   base::MessageLoopForUI message_loop;
 321
 322   ui::OzonePlatform::InitializeForUI();
 323   ui::KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()
 324       ->SetCurrentLayoutByName("us");
 325
 326   base::RunLoop run_loop;
 327
 328   WindowManager window_manager(run_loop.QuitClosure());
 329
 330   run_loop.Run();
 331
 332   return 0;
 333 }