Account for device scale factor in AppWindow.setShape(), under Windows.

ui/views/widget/desktop_aura/desktop_window_tree_host_win.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/widget/desktop_aura/desktop_window_tree_host_win.h"
 
 #include "base/win/metro.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 262 matching lines @@
   monitor_info.cbSize = sizeof(monitor_info);
   GetMonitorInfo(MonitorFromWindow(message_handler_->hwnd(),
                                    MONITOR_DEFAULTTONEAREST),
                  &monitor_info);
   gfx::Rect pixel_bounds = gfx::Rect(monitor_info.rcWork);
   return gfx::win::ScreenToDIPRect(pixel_bounds);
 }
 
 void DesktopWindowTreeHostWin::SetShape(gfx::NativeRegion native_region) {
   if (native_region) {
-    message_handler_->SetRegion(gfx::CreateHRGNFromSkRegion(*native_region));
+    // TODO(wez): This would be a lot simpler if we were passed an SkPath.
+    // See crbug.com/410593.
+    gfx::NativeRegion shape = native_region;
+    SkRegion device_region;

[sky, 2014/09/04 18:00:56]

Does Skia not have a way to scale a SkRegion? Seems like that would be the ideal
way to go about this.

[Wez, 2014/09/04 18:19:08]

Sadly no. :(

My guess is that you're really intended to do this with SkPath (hence my comment
above), which has float coordinates, so can be scaled efficiently, and then
convert to SkRegion at the last possible moment, otherwise SkRegion will need
(inefficient) code approximating what I have below.

You can [usually] convert an SkRegion to an SkPath, which has float coordinates
and can be efficiently scaled to a new size, and then convertd back to SkRegion,
or in this case directly to HRGN, but of course that relies on the (non-trivial)
conversion back and forth.

+    if (gfx::IsInHighDPIMode()) {
+      shape = &device_region;
+      const float& scale = gfx::GetDPIScale();
+      std::vector<SkIRect> rects;
+      for (SkRegion::Iterator it(*native_region); !it.done(); it.next()) {
+        const SkIRect& rect = it.rect();
+        SkRect scaled_rect =
+            SkRect::MakeLTRB(rect.left() * scale, rect.top() * scale,
+                             rect.right() * scale, rect.bottom() * scale);
+        SkIRect rounded_scaled_rect;
+        scaled_rect.roundOut(&rounded_scaled_rect);
+        rects.push_back(rounded_scaled_rect);
+      }
+      if (!rects.empty())
+        device_region.setRects(&rects[0], rects.size());
+    }
+
+    message_handler_->SetRegion(gfx::CreateHRGNFromSkRegion(*shape));
   } else {
     message_handler_->SetRegion(NULL);
   }
 
   delete native_region;
 }
 
 void DesktopWindowTreeHostWin::Activate() {
   message_handler_->Activate();
 }
@@ skipping 645 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostWin(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views