Fix PepperView to let PPAPI up-scale on high-DPI devices where possible.

remoting/client/plugin/pepper_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 "remoting/client/plugin/pepper_view.h"
 
 #include <functional>
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 64 matching lines @@
 
   pp::Rect pp_size = view.GetRect();
   SkISize new_size_dips = SkISize::Make(pp_size.width(), pp_size.height());
   pp::ViewDev view_dev(view);
   float new_scale = view_dev.GetDeviceScale();
 
   if (view_size_dips_ != new_size_dips || view_scale_ != new_scale) {
     view_changed = true;
     view_scale_ = new_scale;
     view_size_dips_ = new_size_dips;
-    view_size_ = SkISize::Make(ceilf(view_size_dips_.width() * view_scale_),
-                               ceilf(view_size_dips_.height() * view_scale_));
 
+    // If |view_scale_| is > 1.0 then the device is high-DPI, and there are
+    // actually |view_scale_| physical pixels for every one Density Independent
+    // Pixel (DIP).  If we specify a scale of 1.0 to Graphics2D then we can
+    // render at DIP resolution and let PPAPI up-scale for high-DPI devices.
+    // Note that |view_scale_| is DIPS->pixels, |scale| is pixels->DIPS.
+    float scale = 1.0f;
+    view_size_ = view_size_dips_;
+
+    // If the view's DIP dimensions don't match the source then let the frame
+    // producer do the scaling, and render at device resolution.
+    if (view_size_dips_ != source_size_) {
+      scale = 1.0f / view_scale_;
+      view_size_ = SkISize::Make(ceilf(view_size_dips_.width() * view_scale_),
+                                 ceilf(view_size_dips_.height() * view_scale_));
+    }
+
+    // Create a 2D rendering context at the chosen frame dimensions.
     pp::Size pp_size = pp::Size(view_size_.width(), view_size_.height());
     graphics2d_ = pp::Graphics2D(instance_, pp_size, true);
 
-    // Ideally we would always let Graphics2D scale us, but the output quality
-    // is lousy, so we don't.

[Jamie, 2012/12/18 19:45:32]

I take it this comment is no longer true?

[Wez, 2012/12/18 19:47:23]

No; it's still true for non-integer scale factors but for integer factors
Graphics2D scaling is preferable since it hasn't the same sub-sampling errors.

     pp::Graphics2D_Dev graphics2d_dev(graphics2d_);
-    graphics2d_dev.SetScale(1.0f / view_scale_);
+    graphics2d_dev.SetScale(scale);
 
     bool result = instance_->BindGraphics(graphics2d_);
 
     // There is no good way to handle this error currently.
     DCHECK(result) << "Couldn't bind the device context.";
   }
 
   pp::Rect pp_clip = view.GetClipRect();
   SkIRect new_clip = SkIRect::MakeLTRB(floorf(pp_clip.x() * view_scale_),
                                        floorf(pp_clip.y() * view_scale_),
@@ skipping 171 matching lines @@
 
   // If there is a buffer queued for rendering then render it now.
   if (merge_buffer_ != NULL) {
     buffer = merge_buffer_;
     merge_buffer_ = NULL;
     FlushBuffer(merge_clip_area_, buffer, merge_region_);
   }
 }
 
 }  // namespace remoting