Add flag to launch two displays for mus+ash.

services/ui/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 "services/ui/ws/platform_display.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "cc/ipc/quads.mojom.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 44 matching lines @@
 
 DefaultPlatformDisplay::DefaultPlatformDisplay(
     const PlatformDisplayInitParams& init_params)
     : display_id_(init_params.display_id),
 #if !defined(OS_ANDROID)
       cursor_loader_(ui::CursorLoader::Create()),
 #endif
       frame_generator_(new FrameGenerator(this,
                                           init_params.gpu_state,
                                           init_params.surfaces_state)) {
-  metrics_.size_in_pixels = init_params.display_bounds.size();
+  metrics_.bounds = init_params.display_bounds;
   // TODO(rjkroege): Preserve the display_id when Ozone platform can use it.
 }
 
 void DefaultPlatformDisplay::Init(PlatformDisplayDelegate* delegate) {
   delegate_ = delegate;
 
-  gfx::Rect bounds(metrics_.size_in_pixels);
 #if defined(OS_WIN)
-  platform_window_.reset(new ui::WinWindow(this, bounds));
+  platform_window_.reset(new ui::WinWindow(this, metrics_.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)
-  platform_window_ =
-      ui::OzonePlatform::GetInstance()->CreatePlatformWindow(this, bounds);
+  platform_window_ = ui::OzonePlatform::GetInstance()->CreatePlatformWindow(
+      this, metrics_.bounds);
 #else
   NOTREACHED() << "Unsupported platform";
 #endif
-  platform_window_->SetBounds(bounds);
+  platform_window_->SetBounds(metrics_.bounds);
   platform_window_->Show();
 }
 
 DefaultPlatformDisplay::~DefaultPlatformDisplay() {
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
 
   frame_generator_.reset();
   // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state. But destroy the surface
@@ skipping 65 matching lines @@
 }
 
 bool DefaultPlatformDisplay::IsFramePending() const {
   return frame_generator_->is_frame_pending();
 }
 
 int64_t DefaultPlatformDisplay::GetDisplayId() const {
   return display_id_;
 }
 
-void DefaultPlatformDisplay::UpdateMetrics(const gfx::Size& size,
+gfx::Rect DefaultPlatformDisplay::GetBounds() const {
+  return metrics_.bounds;
+}
+
+void DefaultPlatformDisplay::UpdateMetrics(const gfx::Rect& bounds,
                                            float device_scale_factor) {
   if (display::Display::HasForceDeviceScaleFactor())
     device_scale_factor = display::Display::GetForcedDeviceScaleFactor();
-  if (metrics_.size_in_pixels == size &&
+  if (metrics_.bounds == bounds &&
       metrics_.device_scale_factor == device_scale_factor)
     return;
 
   ViewportMetrics old_metrics = metrics_;
-  metrics_.size_in_pixels = size;
+  metrics_.bounds = bounds;
   metrics_.device_scale_factor = device_scale_factor;
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
 void DefaultPlatformDisplay::OnBoundsChanged(const gfx::Rect& new_bounds) {
-  UpdateMetrics(new_bounds.size(), metrics_.device_scale_factor);
+  // TODO(kylechar): We should keep track of the actual top left of the window
+  // and also the internal top left of the window (eg. first window is at 0,0).
+  UpdateMetrics(new_bounds, metrics_.device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnDamageRect(const gfx::Rect& damaged_region) {
   frame_generator_->RequestRedraw(damaged_region);
 }
 
 void DefaultPlatformDisplay::DispatchEvent(ui::Event* event) {
   if (event->IsScrollEvent()) {
     // TODO(moshayedi): crbug.com/602859. Dispatch scroll events as
     // they are once we have proper support for scroll events.
@@ skipping 44 matching lines @@
     ui::PlatformWindowState new_state) {}
 
 void DefaultPlatformDisplay::OnLostCapture() {
   delegate_->OnNativeCaptureLost();
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_scale_factor) {
   frame_generator_->OnAcceleratedWidgetAvailable(widget);
-  UpdateMetrics(metrics_.size_in_pixels, device_scale_factor);
+  UpdateMetrics(metrics_.bounds, device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void DefaultPlatformDisplay::OnActivationChanged(bool active) {}
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> output_request) {
@@ skipping 13 matching lines @@
   return delegate_ ? delegate_->IsInHighContrastMode() : false;
 }
 
 const ViewportMetrics& DefaultPlatformDisplay::GetViewportMetrics() {
   return metrics_;
 }
 
 }  // namespace ws
 
 }  // namespace ui