gpu: media: RenderingHelper: wait for the display & window to be ready

content/common/gpu/media/rendering_helper.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/gpu/media/rendering_helper.h"
 
 #include <algorithm>
 #include <numeric>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/stringize_macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"
 #endif
 
 #if defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
 #include "ui/gl/gl_surface_glx.h"
 #define GL_VARIANT_GLX 1
 #else
 #include "ui/gl/gl_surface_egl.h"
 #define GL_VARIANT_EGL 1
 #endif
 
 #if defined(USE_OZONE)
 #if defined(OS_CHROMEOS)
 #include "ui/display/chromeos/display_configurator.h"
+#include "ui/display/types/display_constants.h"
 #endif  // defined(OS_CHROMEOS)
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/ui_thread_gpu.h"
 #include "ui/platform_window/platform_window.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #endif  // defined(USE_OZONE)
 
 // Helper for Shader creation.
 static void CreateShader(GLuint program,
                          GLenum type,
@@ skipping 11 matching lines @@
   }
   glAttachShader(program, shader);
   glDeleteShader(shader);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
 namespace content {
 
 #if defined(USE_OZONE)
 
+class DisplayConfiguratorObserver : public ui::DisplayConfigurator::Observer {
+ public:
+  DisplayConfiguratorObserver(base::RunLoop* loop) : loop_(loop) {}
+  ~DisplayConfiguratorObserver() override {}
+
+ private:
+  // ui::DisplayConfigurator::Observer overrides:
+  void OnDisplayModeChanged(
+      const ui::DisplayConfigurator::DisplayStateList& outputs) override {
+    if (!loop_)
+      return;
+    loop_->Quit();
+    loop_ = nullptr;
+  }
+  void OnDisplayModeChangeFailed(
+      ui::MultipleDisplayState failed_new_state) override {
+    LOG(FATAL) << "Could not setup display";
+  }
+
+  base::RunLoop* loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorObserver);
+};
+
 class RenderingHelper::StubOzoneDelegate : public ui::PlatformWindowDelegate {
  public:
-  StubOzoneDelegate() : accelerated_widget_(gfx::kNullAcceleratedWidget) {
+  StubOzoneDelegate(base::RunLoop* loop)
+      : accelerated_widget_(gfx::kNullAcceleratedWidget), loop_(loop) {
     ui_thread_gpu_.Initialize();
     platform_window_ = ui::OzonePlatform::GetInstance()->CreatePlatformWindow(
         this, gfx::Rect());
   }
   virtual ~StubOzoneDelegate() {}
 
-  void OnBoundsChanged(const gfx::Rect& new_bounds) override {}
+  void OnBoundsChanged(const gfx::Rect& new_bounds) override {
+    if (!loop_)
+      return;
+    loop_->Quit();
+    loop_ = nullptr;
+  }
 
   void OnDamageRect(const gfx::Rect& damaged_region) override {}
 
   void DispatchEvent(ui::Event* event) override {}
 
   void OnCloseRequest() override {}
   void OnClosed() override {}
 
   void OnWindowStateChanged(ui::PlatformWindowState new_state) override {}
 
@@ skipping 10 matching lines @@
   }
 
   gfx::Size GetSize() { return platform_window_->GetBounds().size(); }
 
   ui::PlatformWindow* platform_window() const { return platform_window_.get(); }
 
  private:
   ui::UiThreadGpu ui_thread_gpu_;
   scoped_ptr<ui::PlatformWindow> platform_window_;
   gfx::AcceleratedWidget accelerated_widget_;
+  base::RunLoop* loop_;
 
   DISALLOW_COPY_AND_ASSIGN(StubOzoneDelegate);
 };
 
 #endif  // defined(USE_OZONE)
 
 RenderingHelperParams::RenderingHelperParams()
     : rendering_fps(0), warm_up_iterations(0), render_as_thumbnails(false) {
 }
 
@@ skipping 99 matching lines @@
                           0 /* border width */,
                           depth,
                           CopyFromParent /* class */,
                           CopyFromParent /* visual */,
                           (CWBackPixel | CWOverrideRedirect),
                           &window_attributes);
   XStoreName(display, window_, "VideoDecodeAcceleratorTest");
   XSelectInput(display, window_, ExposureMask);
   XMapWindow(display, window_);
 #elif defined(USE_OZONE)
-  platform_window_delegate_.reset(new RenderingHelper::StubOzoneDelegate());
+  base::RunLoop wait_resize_loop;
+
+  platform_window_delegate_.reset(
+      new RenderingHelper::StubOzoneDelegate(&wait_resize_loop));
   window_ = platform_window_delegate_->accelerated_widget();
 #if defined(OS_CHROMEOS)
-  display_configurator_.reset(new ui::DisplayConfigurator());
+  // We hold onto the main loop here to wait for the DisplayController
+  // to give us the size of the display so we can create a window of
+  // the same size.
+  base::MessageLoop::ScopedNestableTaskAllower nest_loop(
+      base::MessageLoop::current());
+  base::RunLoop wait_mode_change_loop;
+  DisplayConfiguratorObserver display_observer(&wait_mode_change_loop);
+  display_configurator_.reset(new ui::DisplayConfigurator);
+  display_configurator_->AddObserver(&display_observer);

[dnicoara, 2015/01/21 16:23:57]

You can remove all the nested message loops and the observer in favor of the
following:

display_configurator_.reset(new ui::DisplayConfigurator());
display_configurator_->Init(true);

// This needs to be called right after Init().
display_configurator_->ForceInitialConfigure(0);
// Make sure all the display configuration is applied.
base::RunLoop().RunUntilIdle();

display_configurator_->SetDisplayMode(ui::MULTIPLE_DISPLAY_STATE_SINGLE);
// Make sure all the display configuration is applied.
base::RunLoop().RunUntilIdle();

[llandwerlin-old, 2015/01/21 18:45:51]

Done.

   display_configurator_->Init(true);
+  display_configurator_->SetDisplayMode(ui::MULTIPLE_DISPLAY_STATE_SINGLE);

[Owen Lin, 2015/01/23 08:57:38]

Why this line is removed ?

[dnicoara, 2015/01/23 15:10:13]

You don't need to set the display mode since ForceInitialConfigure() will do it.
The subtle detail is that if you have an external display attached, setting the
mode like this will fail. You'd need to also set the power to turn the external
off in order to be able to set the state to SINGLE.

The easiest way would probably be to just use the state set in
ForceInitialConfigure() and use DisplayConfigurator::cached_displays() to get
the first display and use it's bounds when initializing the window.

   display_configurator_->ForceInitialConfigure(0);
+  // Wait for the display to probe the screen's size.
+  wait_mode_change_loop.Run();
+  display_configurator_->RemoveObserver(&display_observer);
   platform_window_delegate_->platform_window()->SetBounds(
       gfx::Rect(display_configurator_->framebuffer_size()));
 #else
   platform_window_delegate_->platform_window()->SetBounds(gfx::Rect(800, 600));
 #endif
+  // Wait for the window to be resized.
+  wait_resize_loop.Run();

[dnicoara, 2015/01/21 16:23:57]

This also needs to be replaced by a "base::RunLoop().RunUntilIdle()"

[llandwerlin-old, 2015/01/21 18:45:51]

Done.

 #else
 #error unknown platform
 #endif
   CHECK(window_ != gfx::kNullAcceleratedWidget);
 
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(window_);
   screen_size_ = gl_surface_->GetSize();
 
   gl_context_ = gfx::GLContext::CreateGLContext(
       NULL, gl_surface_.get(), gfx::PreferIntegratedGpu);
@@ skipping 529 matching lines @@
   // When the rendering falls behind, drops frames.
   while (scheduled_render_time_ < target) {
     scheduled_render_time_ += frame_duration_;
     DropOneFrameForAllVideos();
   }
 
   message_loop_->PostDelayedTask(
       FROM_HERE, render_task_.callback(), target - now);
 }
 }  // namespace content