Unified Desktop: Support 2xDSF display

ash/display/root_window_transformers.cc

 // Copyright (c) 2013 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 "ash/display/root_window_transformers.h"
 
 #include <cmath>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
@@ skipping 127 matching lines @@
 // RootWindowTransformer for ash environment.
 class AshRootWindowTransformer : public RootWindowTransformer {
  public:
   AshRootWindowTransformer(aura::Window* root,
                            const gfx::Display& display)
       : root_window_(root) {
     DisplayManager* display_manager = Shell::GetInstance()->display_manager();
     DisplayInfo info = display_manager->GetDisplayInfo(display.id());
     host_insets_ = info.GetOverscanInsetsInPixel();
     root_window_ui_scale_ = info.GetEffectiveUIScale();
-    // In unified mode, the scaling happen when mirroring, so don't apply
-    // scaling to the root window.
-    const float apply_ui_scale =
-        display_manager->IsInUnifiedMode() ? 1.0f : root_window_ui_scale_;
-
     root_window_bounds_transform_ =
-        CreateInsetsAndScaleTransform(
-            host_insets_, display.device_scale_factor(), apply_ui_scale) *
+        CreateInsetsAndScaleTransform(host_insets_,
+                                      display.device_scale_factor(),
+                                      root_window_ui_scale_) *
         CreateRotationTransform(root, display);
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAshEnableMirroredScreen)) {
       // Apply the tranform that flips the screen image horizontally so that
       // the screen looks normal when reflected on a mirror.
       root_window_bounds_transform_ =
           root_window_bounds_transform_ * CreateMirrorTransform(display);
     }
     transform_ = root_window_bounds_transform_ * CreateMagnifierTransform(root);
 
     CHECK(transform_.GetInverse(&invert_transform_));
   }
 
   // aura::RootWindowTransformer overrides:
   gfx::Transform GetTransform() const override { return transform_; }
   gfx::Transform GetInverseTransform() const override {
     return invert_transform_;
   }
   gfx::Rect GetRootWindowBounds(const gfx::Size& host_size) const override {
     gfx::Rect bounds(host_size);
     bounds.Inset(host_insets_);
     bounds = ui::ConvertRectToDIP(root_window_->layer(), bounds);
     gfx::RectF new_bounds(bounds);
     root_window_bounds_transform_.TransformRect(&new_bounds);
-    if (Shell::GetInstance()->display_manager()->IsInUnifiedMode()) {
-      new_bounds.Scale(root_window_ui_scale_);
-    } else {
-      // Apply |root_window_scale_| twice as the downscaling
-      // is already applied once in |SetTransformInternal()|.
-      // TODO(oshima): This is a bit ugly. Consider specifying
-      // the pseudo host resolution instead.
-      new_bounds.Scale(root_window_ui_scale_ * root_window_ui_scale_);
-    }
+    // Apply |root_window_scale_| twice as the downscaling
+    // is already applied once in |SetTransformInternal()|.
+    // TODO(oshima): This is a bit ugly. Consider specifying
+    // the pseudo host resolution instead.
+    new_bounds.Scale(root_window_ui_scale_ * root_window_ui_scale_);
     // Ignore the origin because RootWindow's insets are handled by
     // the transform.
     // Floor the size because the bounds is no longer aligned to
     // backing pixel when |root_window_scale_| is specified
     // (850 height at 1.25 scale becomes 1062.5 for example.)
     return gfx::Rect(gfx::ToFlooredSize(new_bounds.size()));
   }
 
   gfx::Insets GetHostInsets() const override { return host_insets_; }
 
@@ skipping 81 matching lines @@
   gfx::Rect root_bounds_;
   gfx::Insets insets_;
 
   DISALLOW_COPY_AND_ASSIGN(MirrorRootWindowTransformer);
 };
 
 class PartialBoundsRootWindowTransformer : public RootWindowTransformer {
  public:
   PartialBoundsRootWindowTransformer(const gfx::Rect& screen_bounds,
                                      const gfx::Display& display) {
+    gfx::Display unified_display =
+        Shell::GetInstance()->GetScreen()->GetPrimaryDisplay();
     DisplayInfo display_info =
         Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
     root_bounds_ = gfx::Rect(display_info.bounds_in_native().size());
-    float scale =
-        root_bounds_.height() / static_cast<float>(screen_bounds.height());
+    float scale = root_bounds_.height() /
+                  static_cast<float>(screen_bounds.height()) /
+                  unified_display.device_scale_factor();
     transform_.Scale(scale, scale);
     transform_.Translate(-SkIntToMScalar(display.bounds().x()),
                          -SkIntToMScalar(display.bounds().y()));
   }
 
   // RootWindowTransformer:
   gfx::Transform GetTransform() const override { return transform_; }
   gfx::Transform GetInverseTransform() const override {
     gfx::Transform invert;
     CHECK(transform_.GetInverse(&invert));
@@ skipping 26 matching lines @@
                                          mirror_display_info);
 }
 
 RootWindowTransformer* CreateRootWindowTransformerForUnifiedDesktop(
     const gfx::Rect& screen_bounds,
     const gfx::Display& display) {
   return new PartialBoundsRootWindowTransformer(screen_bounds, display);
 }
 
 }  // namespace ash