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