Move DIP translation from ui/aura to ui/compositor

ui/aura/root_window.cc

 // Copyright (c) 2012 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 "ui/aura/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
+#include "ui/aura/monitor_manager.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/compositor/compositor.h"
+#include "ui/gfx/compositor/dip_util.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animator.h"
+#include "ui/gfx/monitor.h"
+#include "ui/gfx/screen.h"
 
 using std::vector;
 
 namespace aura {
 
 namespace {
 
 // Returns true if |target| has a non-client (frame) component at |location|,
 // in window coordinates.
 bool IsNonClientLocation(Window* target, const gfx::Point& location) {
   if (!target->delegate())
     return false;
   int hit_test_code = target->delegate()->GetNonClientComponent(location);
   return hit_test_code != HTCLIENT && hit_test_code != HTNOWHERE;
 }
 
 typedef std::vector<EventFilter*> EventFilters;
 
 void GetEventFiltersToNotify(Window* target, EventFilters* filters) {
   while (target) {
     if (target->event_filter())
       filters->push_back(target->event_filter());
     target = target->parent();
   }
 }
 
+float GetDeviceScaleFactorFromMonitor(const aura::Window* window) {
+  MonitorManager* monitor_manager = Env::GetInstance()->monitor_manager();
+  return monitor_manager->GetMonitorNearestWindow(window).device_scale_factor();
+}
+
 const int kCompositorLockTimeoutMs = 67;
 
 }  // namespace
 
 CompositorLock::CompositorLock(RootWindow* root_window)
     : root_window_(root_window) {
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
       kCompositorLockTimeoutMs);
@@ skipping 36 matching lines @@
       defer_draw_scheduling_(false),
       mouse_move_hold_count_(0),
       should_hold_mouse_moves_(false),
       compositor_lock_(NULL),
       draw_on_compositor_unlock_(false),
       draw_trace_count_(0) {
   SetName("RootWindow");
   should_hold_mouse_moves_ = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAuraDisableHoldMouseMoves);
 
-  compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget(),
-      host_->GetBounds().size()));
+  compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
 }
 
 RootWindow::~RootWindow() {
   if (compositor_lock_) {
     // No need to schedule a draw, we're going away.
     draw_on_compositor_unlock_ = false;
     compositor_lock_->CancelLock();
     DCHECK(!compositor_lock_);
   }
   compositor_->RemoveObserver(this);
   // Make sure to destroy the compositor before terminating so that state is
   // cleared and we don't hit asserts.
   compositor_.reset();
 
   // Tear down in reverse.  Frees any references held by the host.
   host_.reset(NULL);
 
   // An observer may have been added by an animation on the RootWindow.
   layer()->GetAnimator()->RemoveObserver(this);
 }
 
 void RootWindow::Init() {
+  compositor()->WidgetScaleOrSizeChanged(
+      GetDeviceScaleFactorFromMonitor(this), host_->GetBounds().size());
   Window::Init(ui::LAYER_NOT_DRAWN);
-  last_mouse_location_ = ConvertPointToDIP(this, host_->QueryMouseLocation());
-  SetBounds(ConvertRectToDIP(this, gfx::Rect(host_->GetBounds().size())));
+  last_mouse_location_ =
+      ui::ConvertPointToDIP(layer(), host_->QueryMouseLocation());
+  SetBounds(
+      ui::ConvertRectToDIP(layer(), gfx::Rect(host_->GetBounds().size())));
   Show();
   compositor()->SetRootLayer(layer());
   host_->SetRootWindow(this);
 }
 
 void RootWindow::ShowRootWindow() {
   host_->Show();
 }
 
-void RootWindow::SetHostSize(const gfx::Size& size) {
+void RootWindow::SetHostSize(const gfx::Size& size_in_pixel) {
   DispatchHeldMouseMove();
   gfx::Rect bounds = host_->GetBounds();
-  bounds.set_size(size);
+  bounds.set_size(size_in_pixel);
   host_->SetBounds(bounds);
   // Requery the location to constrain it within the new root window size.
-  last_mouse_location_ = ConvertPointToDIP(this, host_->QueryMouseLocation());
+  last_mouse_location_ =
+      ui::ConvertPointToDIP(layer(), host_->QueryMouseLocation());
   synthesize_mouse_move_ = false;
 }
 
 gfx::Size RootWindow::GetHostSize() const {
   return host_->GetBounds().size();
 }
 
-void RootWindow::SetHostBounds(const gfx::Rect& bounds) {
+void RootWindow::SetHostBounds(const gfx::Rect& bounds_in_pixel) {
   DispatchHeldMouseMove();
-  host_->SetBounds(bounds);
+  host_->SetBounds(bounds_in_pixel);
   // Requery the location to constrain it within the new root window size.
-  last_mouse_location_ = ConvertPointToDIP(this, host_->QueryMouseLocation());
+  last_mouse_location_ =
+      ui::ConvertPointToDIP(layer(), host_->QueryMouseLocation());
   synthesize_mouse_move_ = false;
 }
 
 gfx::Point RootWindow::GetHostOrigin() const {
   return host_->GetBounds().origin();
 }
 
 void RootWindow::SetCursor(gfx::NativeCursor cursor) {
   last_cursor_ = cursor;
   // A lot of code seems to depend on NULL cursors actually showing an arrow,
   // so just pass everything along to the host.
   host_->SetCursor(cursor);
 }
 
 void RootWindow::ShowCursor(bool show) {
   cursor_shown_ = show;
   host_->ShowCursor(show);
 }
 
 void RootWindow::MoveCursorTo(const gfx::Point& location_in_dip) {
-  host_->MoveCursorTo(ConvertPointToPixel(this, location_in_dip));
+  host_->MoveCursorTo(ui::ConvertPointToPixel(layer(), location_in_dip));
 }
 
 bool RootWindow::ConfineCursorToWindow() {
   // We would like to be able to confine the cursor to that window. However,
   // currently, we do not have such functionality in X. So we just confine
   // to the root window. This is ok because this option is currently only
   // being used in fullscreen mode, so root_window bounds = window bounds.
   return host_->ConfineCursorToRootWindow();
 }
 
@@ skipping 41 matching lines @@
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   if (client && !client->CanProcessEventsWithinSubtree(focused_window_)) {
     SetFocusedWindow(NULL, NULL);
     return false;
   }
   return ProcessKeyEvent(focused_window_, &translated_event);
 }
 
 bool RootWindow::DispatchScrollEvent(ScrollEvent* event) {
   DispatchHeldMouseMove();
-#if defined(ENABLE_DIP)
-  float scale = GetMonitorScaleFactor(this);
-  ui::Transform transform;
-  transform.SetScale(scale, scale);
-  transform.ConcatTransform(layer()->transform());
-  event->UpdateForRootTransform(transform);
-#else
-  event->UpdateForRootTransform(layer()->transform());
-#endif
+  if (ui::IsDIPEnabled()) {
+    float scale = ui::GetDeviceScaleFactor(layer());
+    ui::Transform transform = layer()->transform();
+    transform.ConcatScale(scale, scale);
+    event->UpdateForRootTransform(transform);
+  } else {
+    event->UpdateForRootTransform(layer()->transform());
+  }
 
   last_mouse_location_ = event->location();
   synthesize_mouse_move_ = false;
 
   Window* target =
       mouse_pressed_handler_ ? mouse_pressed_handler_ : capture_window_;
   if (!target)
     target = GetEventHandlerForPoint(event->location());
 
   if (target && target->delegate()) {
     int flags = event->flags();
     gfx::Point location_in_window = event->location();
     Window::ConvertPointToWindow(this, target, &location_in_window);
     if (IsNonClientLocation(target, location_in_window))
       flags |= ui::EF_IS_NON_CLIENT;
     ScrollEvent translated_event(*event, this, target, event->type(), flags);
     return ProcessMouseEvent(target, &translated_event);
   }
   return false;
 }
 
 bool RootWindow::DispatchTouchEvent(TouchEvent* event) {
   DispatchHeldMouseMove();
-#if defined(ENABLE_DIP)
-  float scale = GetMonitorScaleFactor(this);
-  ui::Transform transform;
-  transform.SetScale(scale, scale);
-  transform.ConcatTransform(layer()->transform());
-  event->UpdateForRootTransform(transform);
-#else
-  event->UpdateForRootTransform(layer()->transform());
-#endif
+  if (ui::IsDIPEnabled()) {
+    float scale = ui::GetDeviceScaleFactor(layer());
+    ui::Transform transform = layer()->transform();
+    transform.ConcatScale(scale, scale);
+    event->UpdateForRootTransform(transform);
+  } else {
+    event->UpdateForRootTransform(layer()->transform());
+  }
   bool handled = false;
 
   GestureConsumer* consumer = gesture_recognizer_->GetTouchLockedTarget(event);
   ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
 
   if (!consumer || !consumer->ignores_events()) {
     Window* target = static_cast<Window*>(consumer);
 
     if (!target && HasCapture(capture_window_, ui::CW_LOCK_TOUCH))
       target = capture_window_;
@@ skipping 50 matching lines @@
 
   if (target) {
     GestureEvent translated_event(*event, this, target);
     ui::GestureStatus status = ProcessGestureEvent(target, &translated_event);
     return status != ui::GESTURE_STATUS_UNKNOWN;
   }
 
   return false;
 }
 
-void RootWindow::OnHostResized(const gfx::Size& size) {
+void RootWindow::OnHostResized(const gfx::Size& size_in_pixel) {
   DispatchHeldMouseMove();
   // The compositor should have the same size as the native root window host.
-  compositor_->WidgetSizeChanged(size);
-  gfx::Size old(ConvertSizeToDIP(this, bounds().size()));
+  // Get the latest scale from monitor because it might have been changed.
+  compositor_->WidgetScaleOrSizeChanged(
+      GetDeviceScaleFactorFromMonitor(this), size_in_pixel);
+  gfx::Size old(bounds().size());
   // The layer, and all the observers should be notified of the
   // transformed size of the root window.
-  gfx::Rect bounds(ConvertSizeToDIP(this, size));
+  gfx::Rect bounds(ui::ConvertSizeToDIP(layer(), size_in_pixel));
   layer()->transform().TransformRect(&bounds);
-  SetBounds(gfx::Rect(bounds.size()));
+  SetBounds(bounds);
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
                     OnRootWindowResized(this, old));
 }
 
 void RootWindow::OnWindowDestroying(Window* window) {
   OnWindowHidden(window, true);
 
   if (window->IsVisible() &&
       window->ContainsPointInRoot(last_mouse_location_)) {
     PostMouseMoveEventAfterWindowChange();
@@ skipping 504 matching lines @@
 
 bool RootWindow::IsFocusedWindow(const Window* window) const {
   return focused_window_ == window;
 }
 
 bool RootWindow::DispatchMouseEventImpl(MouseEvent* event) {
   static const int kMouseButtonFlagMask =
       ui::EF_LEFT_MOUSE_BUTTON |
       ui::EF_MIDDLE_MOUSE_BUTTON |
       ui::EF_RIGHT_MOUSE_BUTTON;
-#if defined(ENABLE_DIP)
-  float scale = GetMonitorScaleFactor(this);
-  ui::Transform transform;
-  transform.SetScale(scale, scale);
-  transform.ConcatTransform(layer()->transform());
-  event->UpdateForRootTransform(transform);
-#else
-  event->UpdateForRootTransform(layer()->transform());
-#endif
+  if (ui::IsDIPEnabled()) {
+    float scale = ui::GetDeviceScaleFactor(layer());
+    ui::Transform transform = layer()->transform();
+    transform.ConcatScale(scale, scale);
+    event->UpdateForRootTransform(transform);
+  } else {
+    event->UpdateForRootTransform(layer()->transform());
+  }
 
   last_mouse_location_ = event->location();
   synthesize_mouse_move_ = false;
 
   Window* target = mouse_pressed_handler_;
   if (!target && HasCapture(capture_window_, ui::CW_LOCK_MOUSE))
     target = capture_window_;
   if (!target)
     target = GetEventHandlerForPoint(event->location());
   switch (event->type()) {
@@ skipping 46 matching lines @@
                  event_factory_.GetWeakPtr()));
 }
 
 void RootWindow::SynthesizeMouseMoveEvent() {
   if (!synthesize_mouse_move_)
     return;
   synthesize_mouse_move_ = false;
 #if !defined(OS_WIN)
   // Temporarily disabled for windows. See crbug.com/112222.
   gfx::Point orig_mouse_location = last_mouse_location_;
-  orig_mouse_location = ConvertPointToPixel(this, orig_mouse_location);
   layer()->transform().TransformPoint(orig_mouse_location);
-  orig_mouse_location = ConvertPointToDIP(this,orig_mouse_location);
 
   // TODO(derat|oshima): Don't use mouse_button_flags_ as it's
   // currently broken. See/ crbug.com/107931.
   MouseEvent event(ui::ET_MOUSE_MOVED,
                    orig_mouse_location,
                    orig_mouse_location,
                    ui::EF_IS_SYNTHESIZED);
   DispatchMouseEvent(&event);
 #endif
 }
 
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura