Implement HiDPI support in Pepper dev interface

ppapi/proxy/ppb_graphics_2d_proxy.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 "ppapi/proxy/ppb_graphics_2d_proxy.h"
 
 #include <string.h>  // For memset.
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 
 using ppapi::thunk::PPB_Graphics2D_API;
 
 namespace ppapi {
 namespace proxy {
 
 class Graphics2D : public Resource, public thunk::PPB_Graphics2D_API {
  public:
   Graphics2D(const HostResource& host_resource,
              const PP_Size& size,
-             PP_Bool is_always_opaque);
+             PP_Bool is_always_opaque,
+             float scale);
   virtual ~Graphics2D();
 
   // Resource.
   virtual PPB_Graphics2D_API* AsPPB_Graphics2D_API();
 
   // PPB_Graphics_2D_API.
   PP_Bool Describe(PP_Size* size, PP_Bool* is_always_opaque);
   void PaintImageData(PP_Resource image_data,
                       const PP_Point* top_left,
                       const PP_Rect* src_rect);
   void Scroll(const PP_Rect* clip_rect,
               const PP_Point* amount);
   void ReplaceContents(PP_Resource image_data);
   int32_t Flush(PP_CompletionCallback callback);
 
   // Notification that the host has sent an ACK for a pending Flush.
   void FlushACK(int32_t result_code);
 
  private:
   PluginDispatcher* GetDispatcher() const {
     return PluginDispatcher::GetForResource(this);
   }
 
   static const ApiID kApiID = API_ID_PPB_GRAPHICS_2D;
 
   PP_Size size_;
   PP_Bool is_always_opaque_;
+  float scale_;
 
   // In the plugin, this is the current callback set for Flushes. When the
   // pointer is non-NULL, we're waiting for a flush ACK.
   scoped_refptr<TrackedCallback> current_flush_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(Graphics2D);
 };
 
 Graphics2D::Graphics2D(const HostResource& host_resource,
                        const PP_Size& size,
-                       PP_Bool is_always_opaque)
+                       PP_Bool is_always_opaque,
+                       float scale)
     : Resource(OBJECT_IS_PROXY, host_resource),
       size_(size),
-      is_always_opaque_(is_always_opaque) {
+      is_always_opaque_(is_always_opaque),
+      scale_(scale) {
 }
 
 Graphics2D::~Graphics2D() {
 }
 
 PPB_Graphics2D_API* Graphics2D::AsPPB_Graphics2D_API() {
   return this;
 }
 
 PP_Bool Graphics2D::Describe(PP_Size* size, PP_Bool* is_always_opaque) {
@@ skipping 66 matching lines @@
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_Graphics2D_Proxy::~PPB_Graphics2D_Proxy() {
 }
 
 // static
 PP_Resource PPB_Graphics2D_Proxy::CreateProxyResource(
     PP_Instance instance,
     const PP_Size& size,
-    PP_Bool is_always_opaque) {
+    PP_Bool is_always_opaque,
+    float scale) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBGraphics2D_Create(
-      kApiID, instance, size, is_always_opaque, &result));
+      kApiID, instance, size, is_always_opaque, scale, &result));
   if (result.is_null())
     return 0;
-  return (new Graphics2D(result, size, is_always_opaque))->GetReference();
+  return (new Graphics2D(result, size, is_always_opaque, scale))
+      ->GetReference();
 }
 
 bool PPB_Graphics2D_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Graphics2D_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_Create,
                         OnHostMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_PaintImageData,
                         OnHostMsgPaintImageData)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_Scroll,
                         OnHostMsgScroll)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_ReplaceContents,
                         OnHostMsgReplaceContents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_Flush,
                         OnHostMsgFlush)
 
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBGraphics2D_FlushACK,
                         OnPluginMsgFlushACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // FIXME(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_Graphics2D_Proxy::OnHostMsgCreate(PP_Instance instance,
                                            const PP_Size& size,
                                            PP_Bool is_always_opaque,
+                                           float scale,
                                            HostResource* result) {
   thunk::EnterResourceCreation enter(instance);
   if (enter.succeeded()) {
     result->SetHostResource(instance, enter.functions()->CreateGraphics2D(
-        instance, size, is_always_opaque));
+        instance, size, is_always_opaque, scale));
   }
 }
 
 void PPB_Graphics2D_Proxy::OnHostMsgPaintImageData(
     const HostResource& graphics_2d,
     const HostResource& image_data,
     const PP_Point& top_left,
     bool src_rect_specified,
     const PP_Rect& src_rect) {
   EnterHostFromHostResource<PPB_Graphics2D_API> enter(graphics_2d);
@@ skipping 41 matching lines @@
 
 void PPB_Graphics2D_Proxy::SendFlushACKToPlugin(
     int32_t result,
     const HostResource& graphics_2d) {
   dispatcher()->Send(new PpapiMsg_PPBGraphics2D_FlushACK(kApiID, graphics_2d,
                                                          result));
 }
 
 }  // namespace proxy
 }  // namespace ppapi