Move DIP translation from ui/aura to ui/compositor

ui/aura/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/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/client/visibility_client.h"
-#include "ui/aura/dip_util.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/compositor.h"
@@ skipping 178 matching lines @@
   // TODO(beng): There may be a better way to handle this, and the existing code
   //             is likely wrong anyway in a multi-monitor world, but this will
   //             do for now.
   if (!GetRootWindow())
     return bounds();
   gfx::Point origin = bounds().origin();
   Window::ConvertPointToWindow(parent_, GetRootWindow(), &origin);
   return gfx::Rect(origin, bounds().size());
 }
 
-const gfx::Rect& Window::GetBoundsInPixel() const {
-  return layer_->bounds();
-}
-
 void Window::SetTransform(const ui::Transform& transform) {
   RootWindow* root_window = GetRootWindow();
   bool contained_mouse = IsVisible() && root_window &&
       ContainsPointInRoot(root_window->last_mouse_location());
   layer()->SetTransform(transform);
   if (root_window)
     root_window->OnWindowTransformed(this, contained_mouse);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
@@ skipping 11 matching lines @@
 }
 
 void Window::SetBounds(const gfx::Rect& new_bounds) {
   if (parent_ && parent_->layout_manager())
     parent_->layout_manager()->SetChildBounds(this, new_bounds);
   else
     SetBoundsInternal(new_bounds);
 }
 
 gfx::Rect Window::GetTargetBounds() const {
-  return ConvertRectToDIP(this, layer_->GetTargetBounds());
+  return layer_->GetTargetBounds();
 }
 
-gfx::Rect Window::bounds() const {
-#if defined(ENABLE_DIP)
-  return ConvertRectToDIP(this, layer_->bounds());
-#else
+const gfx::Rect& Window::bounds() const {
   return layer_->bounds();
-#endif
 }
 
-void Window::SchedulePaintInRect(const gfx::Rect& rect_in_dip) {
-  gfx::Rect rect = ConvertRectToPixel(this, rect_in_dip);
+void Window::SchedulePaintInRect(const gfx::Rect& rect) {
   if (layer_->SchedulePaint(rect)) {
     FOR_EACH_OBSERVER(
-        WindowObserver, observers_, OnWindowPaintScheduled(this, rect_in_dip));
+        WindowObserver, observers_, OnWindowPaintScheduled(this, rect));
   }
 }
 
 void Window::SetExternalTexture(ui::Texture* texture) {
   layer_->SetExternalTexture(texture);
   gfx::Rect region(bounds().size());
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowPaintScheduled(this, region));
 }
 
@@ skipping 101 matching lines @@
   }
   return NULL;
 }
 
 // static
 void Window::ConvertPointToWindow(const Window* source,
                                   const Window* target,
                                   gfx::Point* point) {
   if (!source)
     return;
-  // TODO(oshima): We probably need to handle source's root != target's root
-  // case under multi monitor environment.
-  *point = ConvertPointToPixel(source, *point);
   ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
-  if (target)
-    *point = ConvertPointToDIP(target, *point);
-  else
-    *point = ConvertPointToDIP(source, *point);
 }
 
 gfx::NativeCursor Window::GetCursor(const gfx::Point& point) const {
   return delegate_ ? delegate_->GetCursor(point) : gfx::kNullCursor;
 }
 
 void Window::SetEventFilter(EventFilter* event_filter) {
   event_filter_.reset(event_filter);
 }
 
@@ skipping 183 matching lines @@
   RootWindow* root_window = GetRootWindow();
 
   bool contained_mouse =
       IsVisible() &&
       root_window && ContainsPointInRoot(root_window->last_mouse_location());
 
   const gfx::Rect old_bounds = GetTargetBounds();
 
   // Always need to set the layer's bounds -- even if it is to the same thing.
   // This may cause important side effects such as stopping animation.
-  layer_->SetBounds(ConvertRectToPixel(this, actual_new_bounds));
+  layer_->SetBounds(actual_new_bounds);
 
   // If we're not changing the effective bounds, then we can bail early and skip
   // notifying our listeners.
   if (old_bounds == actual_new_bounds)
     return;
 
   if (layout_manager_.get())
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, actual_new_bounds);
@@ skipping 193 matching lines @@
 void Window::NotifyAddedToRootWindow() {
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowAddedToRootWindow(this));
   for (Window::Windows::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     (*it)->NotifyAddedToRootWindow();
   }
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
-  if (delegate_) {
-#if defined(ENABLE_DIP)
-    float scale = GetMonitorScaleFactor(this);
-    canvas->sk_canvas()->scale(SkFloatToScalar(scale), SkFloatToScalar(scale));
-#endif
+  if (delegate_)
     delegate_->OnPaint(canvas);
-#if defined(ENABLE_DIP)
-    canvas->Restore();
-#endif
-  }
 }
 
 void Window::UpdateLayerName(const std::string& name) {
 #if !defined(NDEBUG)
   DCHECK(layer());
 
   std::string layer_name(name_);
   if (layer_name.empty())
     layer_name.append("Unnamed Window");
 
   if (id_ != -1) {
     char id_buf[10];
     base::snprintf(id_buf, sizeof(id_buf), " %d", id_);
     layer_name.append(id_buf);
   }
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura