Implement HiDPI support in Pepper dev interface

webkit/plugins/ppapi/ppb_graphics_2d_impl.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 "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 141 matching lines @@
 
   // Valid when type == REPLACE.
   scoped_refptr<PPB_ImageData_Impl> replace_image;
 };
 
 PPB_Graphics2D_Impl::PPB_Graphics2D_Impl(PP_Instance instance)
     : Resource(::ppapi::OBJECT_IS_IMPL, instance),
       bound_instance_(NULL),
       offscreen_flush_pending_(false),
       is_always_opaque_(false),
+      scale_(1.0f),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_Graphics2D_Impl::~PPB_Graphics2D_Impl() {
   // LastPluginRefWasDeleted should have aborted all pending callbacks.
   DCHECK(painted_flush_callback_.is_null());
   DCHECK(unpainted_flush_callback_.is_null());
 }
 
 // static
@@ skipping 12 matching lines @@
 bool PPB_Graphics2D_Impl::Init(int width, int height, bool is_always_opaque) {
   // The underlying PPB_ImageData_Impl will validate the dimensions.
   image_data_ = new PPB_ImageData_Impl(pp_instance());
   if (!image_data_->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(),
                          width, height, true) ||
       !image_data_->Map()) {
     image_data_ = NULL;
     return false;
   }
   is_always_opaque_ = is_always_opaque;
+  scale_ = 1.0f;
   return true;
 }
 
 ::ppapi::thunk::PPB_Graphics2D_API*
 PPB_Graphics2D_Impl::AsPPB_Graphics2D_API() {
   return this;
 }
 
 void PPB_Graphics2D_Impl::LastPluginRefWasDeleted() {
   Resource::LastPluginRefWasDeleted();
@@ skipping 167 matching lines @@
   if (nothing_visible) {
     // There's nothing visible to invalidate so just schedule the callback to
     // execute in the next round of the message loop.
     ScheduleOffscreenCallback(FlushCallbackData(callback));
   } else {
     unpainted_flush_callback_.Set(callback);
   }
   return PP_OK_COMPLETIONPENDING;
 }
 
+bool PPB_Graphics2D_Impl::SetScale(float scale) {
+  if (scale > 0.0f) {
+    scale_ = scale;
+    return true;
+  }
+
+  return false;
+}
+
+float PPB_Graphics2D_Impl::GetScale() {
+  return scale_;
+}
+
 bool PPB_Graphics2D_Impl::ReadImageData(PP_Resource image,
                                         const PP_Point* top_left) {
   // Get and validate the image object to paint into.
   EnterResourceNoLock<PPB_ImageData_API> enter(image, true);
   if (enter.failed())
     return false;
   PPB_ImageData_Impl* image_resource =
       static_cast<PPB_ImageData_Impl*>(enter.object());
   if (!PPB_ImageData_Impl::IsImageDataFormatSupported(
           image_resource->format()))
@@ skipping 164 matching lines @@
     backing_bitmap.copyTo(&image, SkBitmap::kARGB_8888_Config);
   else
     image = backing_bitmap;
 
   SkPaint paint;
   if (is_always_opaque_) {
     // When we know the device is opaque, we can disable blending for slightly
     // more optimized painting.
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
   }
-  canvas->drawBitmap(image,
-                     SkIntToScalar(plugin_rect.x()),
-                     SkIntToScalar(plugin_rect.y()),
-                     &paint);
+
+  SkPoint origin;
+  origin.set(SkIntToScalar(plugin_rect.x()), SkIntToScalar(plugin_rect.y()));
+  if (scale_ != 1.0f && scale_ > 0.0f) {
+    float inverse_scale = 1.0f / scale_;
+    origin.scale(inverse_scale);
+    canvas->scale(scale_, scale_);
+  }
+  canvas->drawBitmap(image, origin.x(), origin.y(), &paint);
   canvas->restore();
 #endif
 }
 
 void PPB_Graphics2D_Impl::ViewWillInitiatePaint() {
   // Move any "unpainted" callback to the painted state. See
   // |unpainted_flush_callback_| in the header for more.
   if (!unpainted_flush_callback_.is_null()) {
     DCHECK(painted_flush_callback_.is_null());
     std::swap(painted_flush_callback_, unpainted_flush_callback_);
@@ skipping 101 matching lines @@
 }
 
 bool PPB_Graphics2D_Impl::HasPendingFlush() const {
   return !unpainted_flush_callback_.is_null() ||
          !painted_flush_callback_.is_null() ||
          offscreen_flush_pending_;
 }
 
 }  // namespace ppapi
 }  // namespace webkit