Move DIP translation from ui/aura to ui/compositor

ui/views/view.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/views/view.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #include "ui/views/accessibility/native_view_accessibility_win.h"
 #endif
 
-#if defined(ENABLE_DIP)
-#include "ui/gfx/monitor.h"
-#include "ui/gfx/screen.h"
-#endif
-
 namespace {
 
 // Whether to use accelerated compositing when necessary (e.g. when a view has a
 // transformation).
 #if defined(USE_AURA)
 bool use_acceleration_when_possible = true;
 #else
 bool use_acceleration_when_possible = false;
 #endif
 
@@ skipping 22 matching lines @@
 };
 
 // Returns the top view in |view|'s hierarchy.
 const views::View* GetHierarchyRoot(const views::View* view) {
   const views::View* root = view;
   while (root && root->parent())
     root = root->parent();
   return root;
 }
 
-// Converts the rect in DIP coordinates in DIP to pixel coordinates.
-gfx::Rect ConvertRectToPixel(const views::View* view,
-                             const gfx::Rect& rect_in_dip) {
-#if defined(ENABLE_DIP)
-  // If we don't know in which monitor the window is in, just assume
-  // it's in normal density for now.
-  // TODO(oshima): Re-compute layer_'s bounds when the window is
-  // attached to root window.
-  if (view->GetWidget() && view->GetWidget()->GetNativeView()) {
-    gfx::Monitor monitor = gfx::Screen::GetMonitorNearestWindow(
-        view->GetWidget()->GetNativeView());
-    return gfx::Rect(rect_in_dip.Scale(monitor.device_scale_factor()));
-  }
-#endif
-  return rect_in_dip;
-}
-
 }  // namespace
 
 namespace views {
 
 // static
 ViewsDelegate* ViewsDelegate::views_delegate = NULL;
 
 // static
 const char View::kViewClassName[] = "views/View";
 
@@ skipping 588 matching lines @@
     x_rect = v->ConvertRectToParent(x_rect);
   return x_rect;
 }
 
 // Painting --------------------------------------------------------------------
 
 void View::SchedulePaint() {
   SchedulePaintInRect(GetLocalBounds());
 }
 
-void View::SchedulePaintInRect(const gfx::Rect& rect_in_dip) {
+void View::SchedulePaintInRect(const gfx::Rect& rect) {
   if (!visible_ || !painting_enabled_)
     return;
 
   if (layer()) {
-    layer()->SchedulePaint(ConvertRectToPixel(this, rect_in_dip));
+    layer()->SchedulePaint(rect);
   } else if (parent_) {
     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
-    parent_->SchedulePaintInRect(ConvertRectToParent(rect_in_dip));
+    parent_->SchedulePaintInRect(ConvertRectToParent(rect));
   }
 }
 
 void View::Paint(gfx::Canvas* canvas) {
   TRACE_EVENT0("views", "View::Paint");
 
   ScopedCanvas scoped_canvas(canvas);
 
   // Paint this View and its children, setting the clip rect to the bounds
   // of this View and translating the origin to the local bounds' top left
@@ skipping 517 matching lines @@
   } else {
     for (int i = 0, count = child_count(); i < count; ++i) {
       gfx::Point new_offset(offset.x() + child_at(i)->GetMirroredX(),
                             offset.y() + child_at(i)->y());
       child_at(i)->UpdateChildLayerBounds(new_offset);
     }
   }
 }
 
 void View::OnPaintLayer(gfx::Canvas* canvas) {
-#if defined(ENABLE_DIP)
-  scoped_ptr<ScopedCanvas> scoped_canvas;
-  if (layer() && GetWidget() && GetWidget()->GetNativeView()) {
-    scoped_canvas.reset(new ScopedCanvas(canvas));
-    float scale =
-        gfx::Screen::GetMonitorNearestWindow(GetWidget()->GetNativeView()).
-        device_scale_factor();
-    canvas->sk_canvas()->scale(SkFloatToScalar(scale), SkFloatToScalar(scale));
-  }
-#endif
-
   if (!layer() || !layer()->fills_bounds_opaquely())
     canvas->DrawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
   PaintCommon(canvas);
 }
 
 void View::ReorderLayers() {
   View* v = this;
   while (v && !v->layer())
     v = v->parent();
 
@@ skipping 480 matching lines @@
 void View::RemoveDescendantToNotify(View* view) {
   DCHECK(view && descendants_to_notify_.get());
   Views::iterator i(std::find(
       descendants_to_notify_->begin(), descendants_to_notify_->end(), view));
   DCHECK(i != descendants_to_notify_->end());
   descendants_to_notify_->erase(i);
   if (descendants_to_notify_->empty())
     descendants_to_notify_.reset();
 }
 
-void View::SetLayerBounds(const gfx::Rect& bounds_in_dip) {
-  layer()->SetBounds(ConvertRectToPixel(this, bounds_in_dip));
+void View::SetLayerBounds(const gfx::Rect& bounds) {
+  layer()->SetBounds(bounds);
 }
 
 // Transformations -------------------------------------------------------------
 
 bool View::GetTransformRelativeTo(const View* ancestor,
                                   ui::Transform* transform) const {
   const View* p = this;
 
   while (p && p != ancestor) {
     transform->ConcatTransform(p->GetTransform());
@@ skipping 322 matching lines @@
 
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   GetWidget()->RunShellDrag(this, data, widget_location, drag_operations);
 #endif  // !defined(OS_MACOSX)
 }
 
 }  // namespace views