Make Chromoting client plugin always render at device DPI.

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"
 #include "base/time.h"
 #include "base/synchronization/waitable_event.h"
 #include "ppapi/cpp/completion_callback.h"
-#include "ppapi/cpp/graphics_2d.h"
+#include "ppapi/cpp/dev/graphics_2d_dev.h"
+#include "ppapi/cpp/dev/view_dev.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
 #include "remoting/base/util.h"
 #include "remoting/client/chromoting_stats.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/frame_producer.h"
 #include "remoting/client/plugin/chromoting_instance.h"
 #include "remoting/client/plugin/pepper_util.h"
@@ skipping 14 matching lines @@
                        FrameProducer* producer)
   : instance_(instance),
     context_(context),
     producer_(producer),
     merge_buffer_(NULL),
     merge_clip_area_(SkIRect::MakeEmpty()),
     view_size_(SkISize::Make(0, 0)),
     clip_area_(SkIRect::MakeEmpty()),
     source_size_(SkISize::Make(0, 0)),
     source_dpi_(SkIPoint::Make(0, 0)),
+    view_size_dips_(SkISize::Make(0, 0)),
+    view_scale_(1.0f),
     flush_pending_(false),
     frame_received_(false) {
   InitiateDrawing();
 }
 
 PepperView::~PepperView() {
   // The producer should now return any pending buffers. At this point, however,
   // ReturnBuffer() tasks scheduled by the producer will not be delivered,
   // so we free all the buffers once the producer's queue is empty.
   base::WaitableEvent done_event(true, false);
   producer_->RequestReturnBuffers(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done_event)));
   done_event.Wait();
 
   merge_buffer_ = NULL;
   while (!buffers_.empty()) {
     FreeBuffer(buffers_.front());
   }
 }
 
-void PepperView::SetView(const SkISize& view_size, const SkIRect& clip_area) {
+void PepperView::SetView(const pp::View& view) {
   bool view_changed = false;
 
-  if (view_size_ != view_size) {
+  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_size_ = view_size;
+    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_));
 
     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.
+    pp::Graphics2DDev graphics2d_dev(graphics2d_);
+    graphics2d_dev.SetScale(1.0f / view_scale_);
+
     bool result = instance_->BindGraphics(graphics2d_);
 
     // There is no good way to handle this error currently.
     DCHECK(result) << "Couldn't bind the device context.";
   }
 
-  if (clip_area_ != clip_area) {
+  pp::Rect pp_clip = view.GetClipRect();
+  SkIRect new_clip = SkIRect::MakeLTRB(floorf(pp_clip.x() * view_scale_),
+                                       floorf(pp_clip.y() * view_scale_),
+                                       ceilf(pp_clip.right() * view_scale_),
+                                       ceilf(pp_clip.bottom() * view_scale_));
+  if (clip_area_ != new_clip) {
     view_changed = true;
 
     // YUV to RGB conversion may require even X and Y coordinates for
     // the top left corner of the clipping area.
-    clip_area_ = AlignRect(clip_area);
+    clip_area_ = AlignRect(new_clip);
     clip_area_.intersect(SkIRect::MakeSize(view_size_));
   }
 
   if (view_changed) {
     producer_->SetOutputSizeAndClip(view_size_, clip_area_);
     InitiateDrawing();
   }
 }
 
 void PepperView::ApplyBuffer(const SkISize& view_size,
@@ skipping 153 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