Start to decouple display::Display from ws::PlatformDisplay.

services/ui/ws/platform_display_default.cc

 // Copyright 2016 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_default.h"
 
 #include "base/memory/ptr_util.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/display/screen_manager.h"
 #include "services/ui/ws/display_client_compositor_frame_sink.h"
-#include "services/ui/ws/platform_display_init_params.h"
 #include "services/ui/ws/server_window.h"
 #include "ui/base/cursor/image_cursors.h"
 #include "ui/display/display.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/platform_window/platform_ime_controller.h"
 #include "ui/platform_window/platform_window.h"
 
 #if defined(OS_WIN)
 #include "ui/platform_window/win/win_window.h"
 #elif defined(USE_X11) && !defined(OS_CHROMEOS)
 #include "ui/platform_window/x11/x11_window.h"
 #elif defined(OS_ANDROID)
 #include "ui/platform_window/android/platform_window_android.h"
 #elif defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace ui {
 namespace ws {
 
 PlatformDisplayDefault::PlatformDisplayDefault(
-    const PlatformDisplayInitParams& init_params)
-    : display_id_(init_params.display_id),
+    ServerWindow* root_window,
+    const display::ViewportMetrics& metrics)
+    : root_window_(root_window),
 #if !defined(OS_ANDROID)
       image_cursors_(new ImageCursors),
 #endif
-      metrics_(init_params.metrics),
+      metrics_(metrics),
       widget_(gfx::kNullAcceleratedWidget),
-      root_window_(init_params.root_window),
-      init_device_scale_factor_(init_params.metrics.device_scale_factor) {
+      init_device_scale_factor_(metrics.device_scale_factor) {
 }
 
 PlatformDisplayDefault::~PlatformDisplayDefault() {
   // 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
   // first because it can still be using the platform window.
   platform_window_.reset();
 }
 
 void PlatformDisplayDefault::Init(PlatformDisplayDelegate* delegate) {
   delegate_ = delegate;
 
-  DCHECK(!metrics_.pixel_size.IsEmpty());
+  const gfx::Rect& bounds = metrics_.bounds_in_pixels;
+  DCHECK(!bounds.size().IsEmpty());
 
-  // TODO(kylechar): The origin here isn't right if any displays have
-  // scale_factor other than 1.0 but will prevent windows from being stacked.
-  gfx::Rect bounds(metrics_.bounds.origin(), metrics_.pixel_size);
 #if defined(OS_WIN)
   platform_window_ = base::MakeUnique<ui::WinWindow>(this, bounds);
 #elif defined(USE_X11) && !defined(OS_CHROMEOS)
   platform_window_ = base::MakeUnique<ui::X11Window>(this, bounds);
 #elif defined(OS_ANDROID)
   platform_window_ = base::MakeUnique<ui::PlatformWindowAndroid>(this);
   platform_window_->SetBounds(bounds);
 #elif defined(USE_OZONE)
   platform_window_ =
       ui::OzonePlatform::GetInstance()->CreatePlatformWindow(this, bounds);
 #else
   NOTREACHED() << "Unsupported platform";
 #endif
 
   platform_window_->Show();
 #if !defined(OS_ANDROID)
   image_cursors_->SetDisplay(delegate_->GetDisplay(),
                              metrics_.device_scale_factor);
 #endif
 }
 
-int64_t PlatformDisplayDefault::GetId() const {
-  return display_id_;
-}
-
 void PlatformDisplayDefault::SetViewportSize(const gfx::Size& size) {
   platform_window_->SetBounds(gfx::Rect(size));
 }
 
 void PlatformDisplayDefault::SetTitle(const base::string16& title) {
   platform_window_->SetTitle(title);
 }
 
 void PlatformDisplayDefault::SetCapture() {
   platform_window_->SetCapture();
@@ skipping 22 matching lines @@
   if (ime)
     ime->UpdateTextInputState(state);
 }
 
 void PlatformDisplayDefault::SetImeVisibility(bool visible) {
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
   if (ime)
     ime->SetImeVisibility(visible);
 }
 
-gfx::Rect PlatformDisplayDefault::GetBounds() const {
-  return metrics_.bounds;
-}
-
 FrameGenerator* PlatformDisplayDefault::GetFrameGenerator() {
   return frame_generator_.get();
 }
 
 bool PlatformDisplayDefault::UpdateViewportMetrics(
     const display::ViewportMetrics& metrics) {
   if (metrics_ == metrics)
     return false;
 
   gfx::Rect bounds = platform_window_->GetBounds();
-  if (bounds.size() != metrics.pixel_size) {
-    bounds.set_size(metrics.pixel_size);
+  if (bounds.size() != metrics.bounds_in_pixels.size()) {
+    bounds.set_size(metrics.bounds_in_pixels.size());
     platform_window_->SetBounds(bounds);
   }
 
   metrics_ = metrics;
   if (frame_generator_)
     frame_generator_->SetDeviceScaleFactor(metrics_.device_scale_factor);
   return true;
 }
 
-const display::ViewportMetrics& PlatformDisplayDefault::GetViewportMetrics()
-    const {
-  return metrics_;
-}
-
 gfx::AcceleratedWidget PlatformDisplayDefault::GetAcceleratedWidget() const {
   return widget_;
 }
 
 void PlatformDisplayDefault::UpdateEventRootLocation(ui::LocatedEvent* event) {
+  // TODO(riajiang): This is broken for HDPI because it mixes PPs and DIPs. See
+  // http://crbug.com/701036 for details.
+  const display::Display& display = delegate_->GetDisplay();
   gfx::Point location = event->location();
-  location.Offset(metrics_.bounds.x(), metrics_.bounds.y());
+  location.Offset(display.bounds().x(), display.bounds().y());
   event->set_root_location(location);
 }
 
 void PlatformDisplayDefault::OnBoundsChanged(const gfx::Rect& new_bounds) {
   // We only care if the window size has changed.
-  if (new_bounds.size() == metrics_.pixel_size)
+  if (new_bounds.size() == metrics_.bounds_in_pixels.size())
     return;
 
-  // TODO(kylechar): Maybe do something here. For CrOS we don't need to support
-  // PlatformWindow initiated resizes. For other platforms we need to do
-  // something but that isn't fully flushed out.
+  // TODO(tonikitoo): Handle the bounds changing in external window mode. The
+  // window should be resized by the WS and it shouldn't involve ScreenManager.
 }
 
 void PlatformDisplayDefault::OnDamageRect(const gfx::Rect& damaged_region) {
   if (frame_generator_)
     frame_generator_->OnWindowDamaged();
 }
 
 void PlatformDisplayDefault::DispatchEvent(ui::Event* event) {
   if (event->IsLocatedEvent())
     UpdateEventRootLocation(event->AsLocatedEvent());
@@ skipping 32 matching lines @@
     // with an accelerator to a character event can change the character, for
     // example, from 'M' to '^M'.
     DCHECK_EQ(key_press_event->key_code(), char_event.key_code());
     DCHECK_EQ(key_press_event->flags(), char_event.flags());
     delegate_->OnEvent(char_event);
   }
 #endif
 }
 
 void PlatformDisplayDefault::OnCloseRequest() {
-  display::ScreenManager::GetInstance()->RequestCloseDisplay(GetId());
+  // TODO(tonikitoo): Handle a close request in external window mode. The window
+  // should be closed by the WS and it shouldn't involve ScreenManager.
+  const int64_t display_id = delegate_->GetDisplay().id();
+  display::ScreenManager::GetInstance()->RequestCloseDisplay(display_id);
 }
 
 void PlatformDisplayDefault::OnClosed() {}
 
 void PlatformDisplayDefault::OnWindowStateChanged(
     ui::PlatformWindowState new_state) {}
 
 void PlatformDisplayDefault::OnLostCapture() {
   delegate_->OnNativeCaptureLost();
 }
@@ skipping 35 matching lines @@
 }
 
 void PlatformDisplayDefault::OnActivationChanged(bool active) {}
 
 bool PlatformDisplayDefault::IsInHighContrastMode() {
   return delegate_ ? delegate_->IsInHighContrastMode() : false;
 }
 
 }  // namespace ws
 }  // namespace ui