view_manager: Remove PlatformViewport abstraction.

components/view_manager/display_manager.cc

Index: components/view_manager/display_manager.cc
diff --git a/components/view_manager/display_manager.cc b/components/view_manager/display_manager.cc
index f82d549a38dd0c32b8171e7dd877ed2da85b0f2d..6e9c23461e49e7bbb29ddf32f146f2648b4eb22b 100644
--- a/components/view_manager/display_manager.cc
+++ b/components/view_manager/display_manager.cc
@@ -16,9 +16,23 @@
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
+#include "mojo/converters/input_events/input_events_type_converters.h"
+#include "mojo/converters/input_events/mojo_extended_key_event_data.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
 #include "mojo/converters/transform/transform_type_converters.h"
+#include "ui/events/event.h"
+#include "ui/events/event_utils.h"
+#include "ui/platform_window/platform_window.h"
+#include "ui/platform_window/stub/stub_window.h"
+
+#if defined(OS_WIN)
+#include "ui/platform_window/win/win_window.h"
+#elif defined(USE_X11)
+#include "ui/platform_window/x11/x11_window.h"
+#elif defined(OS_ANDROID)
+#include "ui/platform_window/android/platform_window_android.h"
+#endif
 
 using mojo::Rect;
 using mojo::Size;
@@ -72,6 +86,15 @@ void DrawViewTree(mojo::Pass* pass,
   pass->shared_quad_states.push_back(sqs.Pass());
 }
 
+float ConvertUIWheelValueToMojoValue(int offset) {
+  // Mojo's event type takes a value between -1 and 1. Normalize by allowing
+  // up to 20 of ui's offset. This is a bit arbitrary.
+  return std::max(
+      -1.0f, std::min(1.0f, static_cast<float>(offset) /
+                                (20 * static_cast<float>(
+                                          ui::MouseWheelEvent::kWheelDelta))));
+}
+
 }  // namespace
 
 // static
@@ -108,10 +131,22 @@ DefaultDisplayManager::DefaultDisplayManager(
 void DefaultDisplayManager::Init(DisplayManagerDelegate* delegate) {
   delegate_ = delegate;
 
-  platform_viewport_ =
-      native_viewport::PlatformViewport::Create(this, is_headless_).Pass();
-  platform_viewport_->Init(gfx::Rect(metrics_.size_in_pixels.To<gfx::Size>()));
-  platform_viewport_->Show();
+  gfx::Rect bounds(metrics_.size_in_pixels.To<gfx::Size>());
+  if (is_headless_) {
+    platform_window_.reset(new ui::StubWindow(this));
+  } else {
+#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));
+#else
+    NOTREACHED() << "Unsupported platform";
+#endif
+  }
+  platform_window_->SetBounds(bounds);
+  platform_window_->Show();
 
   mojo::ContextProviderPtr context_provider;
   context_provider_->Bind(GetProxy(&context_provider).Pass());
@@ -125,14 +160,14 @@ void DefaultDisplayManager::Init(DisplayManagerDelegate* delegate) {
 }
 
 DefaultDisplayManager::~DefaultDisplayManager() {
-  // Destroy before |platform_viewport_| because this will destroy
+  // Destroy before |platform_window_| because this will destroy
   // CommandBufferDriver objects that contain child windows. Otherwise if this
   // class destroys its window first, X errors will occur.
   context_provider_.reset();
 
-  // Destroy the NativeViewport early on as it may call us back during
+  // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state.
-  platform_viewport_.reset();
+  platform_window_.reset();
 }
 
 void DefaultDisplayManager::SchedulePaint(const ServerView* view,
@@ -149,7 +184,7 @@ void DefaultDisplayManager::SchedulePaint(const ServerView* view,
 }
 
 void DefaultDisplayManager::SetViewportSize(const gfx::Size& size) {
-  platform_viewport_->SetBounds(gfx::Rect(size));
+  platform_window_->SetBounds(gfx::Rect(size));
 }
 
 const mojo::ViewportMetrics& DefaultDisplayManager::GetViewportMetrics() {
@@ -188,31 +223,14 @@ void DefaultDisplayManager::WantToDraw() {
       base::Bind(&DefaultDisplayManager::Draw, base::Unretained(this)));
 }
 
-void DefaultDisplayManager::OnAcceleratedWidgetAvailable(
-    gfx::AcceleratedWidget widget,
-    float device_pixel_ratio) {
-  context_provider_->SetAcceleratedWidget(widget);
-  OnMetricsChanged(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
-}
-
-void DefaultDisplayManager::OnAcceleratedWidgetDestroyed() {
-  context_provider_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
-}
-
-void DefaultDisplayManager::OnEvent(mojo::EventPtr event) {
-  delegate_->OnEvent(event.Pass());
-}
-
-void DefaultDisplayManager::OnMetricsChanged(const gfx::Size& size,
-                                             float device_scale_factor) {
-  if ((metrics_.size_in_pixels.To<gfx::Size>() == size) &&
-      (metrics_.device_pixel_ratio == device_scale_factor)) {
+void DefaultDisplayManager::UpdateMetrics(const gfx::Size& size,
+                                          float device_pixel_ratio) {
+  if (metrics_.size_in_pixels.To<gfx::Size>() == size &&
+      metrics_.device_pixel_ratio == device_pixel_ratio)
     return;
-  }
-
   mojo::ViewportMetrics metrics;
   metrics.size_in_pixels = mojo::Size::From(size);
-  metrics.device_pixel_ratio = device_scale_factor;
+  metrics.device_pixel_ratio = device_pixel_ratio;
 
   delegate_->GetRootView()->SetBounds(gfx::Rect(size));
   delegate_->OnViewportMetricsChanged(metrics_, metrics);
@@ -221,8 +239,98 @@ void DefaultDisplayManager::OnMetricsChanged(const gfx::Size& size,
   metrics_.device_pixel_ratio = metrics.device_pixel_ratio;
 }
 
-void DefaultDisplayManager::OnDestroyed() {
+void DefaultDisplayManager::OnBoundsChanged(const gfx::Rect& new_bounds) {
+  UpdateMetrics(new_bounds.size(), metrics_.device_pixel_ratio);
+}
+
+void DefaultDisplayManager::OnDamageRect(const gfx::Rect& damaged_region) {
+}
+
+void DefaultDisplayManager::DispatchEvent(ui::Event* event) {
+  mojo::EventPtr mojo_event(mojo::Event::From(*event));
+  if (event->IsMouseWheelEvent()) {
+    // Mojo's event type has a different meaning for wheel events. Convert
+    // between the two.
+    ui::MouseWheelEvent* wheel_event =
+        static_cast<ui::MouseWheelEvent*>(event);
+    DCHECK(mojo_event->pointer_data);
+    mojo_event->pointer_data->horizontal_wheel =
+        ConvertUIWheelValueToMojoValue(wheel_event->x_offset());
+    mojo_event->pointer_data->horizontal_wheel =
+        ConvertUIWheelValueToMojoValue(wheel_event->y_offset());
+  }
+  delegate_->OnEvent(mojo_event.Pass());
+
+  switch (event->type()) {
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_TOUCH_PRESSED:
+      platform_window_->SetCapture();
+      break;
+    case ui::ET_MOUSE_RELEASED:
+    case ui::ET_TOUCH_RELEASED:
+      platform_window_->ReleaseCapture();
+      break;
+    default:
+      break;
+  }
+
+#if defined(USE_X11)
+  // We want to emulate the WM_CHAR generation behaviour of Windows.
+  //
+  // On Linux, we've previously inserted characters by having
+  // InputMethodAuraLinux take all key down events and send a character event
+  // to the TextInputClient. This causes a mismatch in code that has to be
+  // shared between Windows and Linux, including blink code. Now that we're
+  // trying to have one way of doing things, we need to standardize on and
+  // emulate Windows character events.
+  //
+  // This is equivalent to what we're doing in the current Linux port, but
+  // done once instead of done multiple times in different places.
+  if (event->type() == ui::ET_KEY_PRESSED) {
+    ui::KeyEvent* key_press_event = static_cast<ui::KeyEvent*>(event);
+    ui::KeyEvent char_event(key_press_event->GetCharacter(),
+                            key_press_event->key_code(),
+                            key_press_event->flags());
+
+    DCHECK_EQ(key_press_event->GetCharacter(), char_event.GetCharacter());
+    DCHECK_EQ(key_press_event->key_code(), char_event.key_code());
+    DCHECK_EQ(key_press_event->flags(), char_event.flags());
+
+    char_event.SetExtendedKeyEventData(
+        make_scoped_ptr(new mojo::MojoExtendedKeyEventData(
+            key_press_event->GetLocatedWindowsKeyboardCode(),
+            key_press_event->GetText(),
+            key_press_event->GetUnmodifiedText())));
+    char_event.set_platform_keycode(key_press_event->platform_keycode());
+
+    delegate_->OnEvent(mojo::Event::From(char_event));
+  }
+#endif
+}
+
+void DefaultDisplayManager::OnCloseRequest() {
+  platform_window_->Close();
+}
+
+void DefaultDisplayManager::OnClosed() {
   delegate_->OnDisplayClosed();
 }
 
+void DefaultDisplayManager::OnWindowStateChanged(
+    ui::PlatformWindowState new_state) {
+}
+
+void DefaultDisplayManager::OnLostCapture() {
+}
+
+void DefaultDisplayManager::OnAcceleratedWidgetAvailable(
+    gfx::AcceleratedWidget widget,
+    float device_pixel_ratio) {
+  context_provider_->SetAcceleratedWidget(widget);
+  UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
+}
+
+void DefaultDisplayManager::OnActivationChanged(bool active) {
+}
+
 }  // namespace view_manager