Basic display management for mus

components/mus/ws/platform_display.cc

 // Copyright 2014 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 "components/mus/ws/platform_display.h"
 
 #include "base/numerics/safe_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "components/mus/gles2/gpu_state.h"
 #include "components/mus/public/interfaces/gpu.mojom.h"
 #include "components/mus/public/interfaces/quads.mojom.h"
@@ skipping 145 matching lines @@
 }
 
 DefaultPlatformDisplay::DefaultPlatformDisplay(
     const PlatformDisplayInitParams& init_params)
     : connector_(init_params.connector),
       gpu_state_(init_params.gpu_state),
       surfaces_state_(init_params.surfaces_state),
       delegate_(nullptr),
       draw_timer_(false, false),
       frame_pending_(false),
+      is_configuring_(false),
+      should_configure_(false),
 #if !defined(OS_ANDROID)
       cursor_loader_(ui::CursorLoader::Create()),
 #endif
       weak_factory_(this) {
   metrics_.size_in_pixels = mojo::Size::New();
+#if defined(USE_OZONE)
+  // The size is provided by callback from the display subsystem.
+  metrics_.size_in_pixels->width = 0;
+  metrics_.size_in_pixels->height = 0;
+#else
   metrics_.size_in_pixels->width = 1024;
   metrics_.size_in_pixels->height = 768;
+
+#endif
 }
 
 void DefaultPlatformDisplay::Init(PlatformDisplayDelegate* delegate) {
   delegate_ = delegate;
 
   gfx::Rect bounds(metrics_.size_in_pixels.To<gfx::Size>());
 #if defined(OS_WIN)
   platform_window_.reset(new ui::WinWindow(this, bounds));
 #elif defined(USE_X11)
   platform_window_.reset(new ui::X11Window(this));
 #elif defined(OS_ANDROID)
   platform_window_.reset(new ui::PlatformWindowAndroid(this));
 #elif defined(USE_OZONE)
+  native_display_delegate_ =
+      ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate();
+  native_display_delegate_->AddObserver(this);
+  native_display_delegate_->Initialize();
   platform_window_ =
       ui::OzonePlatform::GetInstance()->CreatePlatformWindow(this, bounds);
+  // Kick off the display configuration process.
+  OnConfigurationChanged();
 #else
   NOTREACHED() << "Unsupported platform";
 #endif
   platform_window_->SetBounds(bounds);
   platform_window_->Show();
 }
 
 DefaultPlatformDisplay::~DefaultPlatformDisplay() {
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
@@ skipping 223 matching lines @@
 }
 
 void DefaultPlatformDisplay::OnActivationChanged(bool active) {}
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> output_request) {
   if (top_level_display_client_)
     top_level_display_client_->RequestCopyOfOutput(std::move(output_request));
 }
 
+// TODO(rjkroege): Support multiple displays.
+// The display subsystem tells us that the display configuration has changed on
+// the first and subsequent change in display parameters. We have to kick this
+// off manually the first time.
+void DefaultPlatformDisplay::OnConfigurationChanged() {
+  DCHECK(native_display_delegate_) << "DefaultDisplayManager::"
+                                      "OnConfigurationChanged requires a "
+                                      "native_display_delegate_ to work.";
+  if (is_configuring_) {
+    should_configure_ = true;
+    return;
+  }
+  is_configuring_ = true;
+  native_display_delegate_->GrabServer();
+  native_display_delegate_->GetDisplays(base::Bind(
+      &DefaultPlatformDisplay::OnDisplaysAquired, base::Unretained(this)));
+}
+
+// The display subsystem calls |OnDisplaysAquired| to deliver |displays|
+// describing the attached displays.
+void DefaultPlatformDisplay::OnDisplaysAquired(
+    const std::vector<ui::DisplaySnapshot*>& displays) {
+  DCHECK(native_display_delegate_) << "DefaultDisplayManager::"
+                                      "OnConfigurationChanged requires a "
+                                      "native_display_delegate_ to work.";
+  CHECK(displays.size() <= 1) << "Mus needs to support more than 1 display\n";
+  gfx::Point origin;
+  for (auto display : displays) {
+    if (!display->native_mode()) {
+      LOG(ERROR) << "Display " << display->display_id()
+                 << " doesn't have a native mode";
+      continue;
+    }
+    // Setup each native display. This places a task on the DRM thread's
+    // runqueue that configures the window size correctly before the call to
+    // Configure.
+    platform_window_->SetBounds(
+        gfx::Rect(origin, display->native_mode()->size()));
+    native_display_delegate_->Configure(
+        *display, display->native_mode(), origin,
+        base::Bind(&DefaultPlatformDisplay::OnDisplayConfigured,
+                   base::Unretained(this),
+                   gfx::Rect(origin, display->native_mode()->size())));
+    origin.Offset(display->native_mode()->size().width(), 0);
+  }
+  native_display_delegate_->UngrabServer();

[sky, 2016/04/18 21:25:00]

What happens if this is deleted after OnConfigurationChanged but before
OnDisplaysAquired?

[rjkroege, 2016/04/21 20:19:53]

Something bad. Appropriate weak pointer-y stuff added.

+  is_configuring_ = false;
+  if (should_configure_) {
+    should_configure_ = false;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&DefaultPlatformDisplay::OnConfigurationChanged,
+                              base::Unretained(this)));

[sky, 2016/04/18 21:25:00]

How is unretained safe here?

[rjkroege, 2016/04/21 20:19:53]

It's not. Fixed.

+  }
+}
+
+// The display subsystem calls  |OnDisplayConfigured| for each display that has
+// been successfully configured.
+// TODO(rjkroege): Per display design discussion, displays should have
+// identifying tokens delivered here.
+void DefaultPlatformDisplay::OnDisplayConfigured(const gfx::Rect& bounds,
+                                                 bool success) {
+  if (!success)
+    LOG(ERROR) << "Failed to configure display at " << bounds.ToString();
+}
+
 }  // namespace ws
 
 }  // namespace mus