Move DIP translation from ui/aura to ui/compositor

ui/gfx/compositor/compositor.h

 // 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.
 
 #ifndef UI_GFX_COMPOSITOR_COMPOSITOR_H_
 #define UI_GFX_COMPOSITOR_COMPOSITOR_H_
 #pragma once
 
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
@@ skipping 93 matching lines @@
   gfx::Size size() const { return size_; }
 
  protected:
   virtual ~Texture();
 
  private:
   friend class base::RefCounted<Texture>;
 
   unsigned int texture_id_;
   bool flipped_;
-  gfx::Size size_;
+  gfx::Size size_;  // in pixel
 
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
 // An interface to allow the compositor to communicate with its owner.
 class COMPOSITOR_EXPORT CompositorDelegate {
  public:
   // Requests the owner to schedule a redraw of the layer tree.
   virtual void ScheduleDraw() = 0;
 
  protected:
   virtual ~CompositorDelegate() {}
 };
 
 // Compositor object to take care of GPU painting.
 // A Browser compositor object is responsible for generating the final
 // displayable form of pixels comprising a single widget's contents. It draws an
 // appropriately transformed texture for each transformed view in the widget's
 // view hierarchy.
 class COMPOSITOR_EXPORT Compositor
     : NON_EXPORTED_BASE(public WebKit::WebLayerTreeViewClient) {
  public:
   Compositor(CompositorDelegate* delegate,
-             gfx::AcceleratedWidget widget,
-             const gfx::Size& size);
+             gfx::AcceleratedWidget widget);
   virtual ~Compositor();
 
   static void Initialize(bool useThread);
   static void Terminate();
 
   // Schedules a redraw of the layer tree associated with this compositor.
   void ScheduleDraw();
 
   // Sets the root of the layer tree drawn by this Compositor. The root layer
   // must have no parent. The compositor's root layer is reset if the root layer
   // is destroyed. NULL can be passed to reset the root layer, in which case the
   // compositor will stop drawing anything.
   // The Compositor does not own the root layer.
   const Layer* root_layer() const { return root_layer_; }
   Layer* root_layer() { return root_layer_; }
   void SetRootLayer(Layer* root_layer);
 
+  // The scale factor of the device that this compositor is
+  // compositing layers on.
+  float device_scale_factor() const { return device_scale_factor_; }
+
   // Draws the scene created by the layer tree and any visual effects. If
   // |force_clear| is true, this will cause the compositor to clear before
   // compositing.
   void Draw(bool force_clear);
 
   // Where possible, draws are scissored to a damage region calculated from
   // changes to layer properties.  This bypasses that and indicates that
   // the whole frame needs to be drawn.
   void ScheduleFullDraw();
 
-  // Reads the region |bounds| of the contents of the last rendered frame
-  // into the given bitmap.
+  // Reads the region |bounds_in_pixel| of the contents of the last rendered
+  // frame into the given bitmap.
   // Returns false if the pixels could not be read.
-  bool ReadPixels(SkBitmap* bitmap, const gfx::Rect& bounds);
+  bool ReadPixels(SkBitmap* bitmap, const gfx::Rect& bounds_in_pixel);
 
-  // Notifies the compositor that the size of the widget that it is
-  // drawing to has changed.
-  void WidgetSizeChanged(const gfx::Size& size);
+  // Notifies the compositor that the device scale factor and size of
+  // the widget that it is drawing to has changed.
+  void WidgetScaleOrSizeChanged(float scale, const gfx::Size& size_in_pixel);
 
-  // Returns the size of the widget that is being drawn to.
+  // Returns the size of the widget that is being drawn to in pixel coordinates.
   const gfx::Size& size() const { return size_; }
 
   // Returns the widget for this compositor.
   gfx::AcceleratedWidget widget() const { return widget_; }
 
   // Compositor does not own observers. It is the responsibility of the
   // observer to remove itself when it is done observing.
   void AddObserver(CompositorObserver* observer);
   void RemoveObserver(CompositorObserver* observer);
   bool HasObserver(CompositorObserver* observer);
 
   // Returns whether a draw is pending, that is, if we're between the Draw call
   // and the OnCompositingEnded.
   bool DrawPending() const { return swap_posted_; }
 
   // Internal functions, called back by command-buffer contexts on swap buffer
   // events.
 
   // Signals swap has been posted.
   void OnSwapBuffersPosted();
 
   // Signals swap has completed.
   void OnSwapBuffersComplete();
 
   // Signals swap has aborted (e.g. lost context).
   void OnSwapBuffersAborted();
 
+  // Translates |transform| with translate_offset, then apply the
+  // device scale factor to the all translate operations in the transform.
+  Transform GetTranslateTransform(const Transform& transform,
+                                  const gfx::Point& translate_offset);
+
   // WebLayerTreeViewClient implementation.
   virtual void updateAnimations(double frameBeginTime);
   virtual void layout();
   virtual void applyScrollAndScale(const WebKit::WebSize& scrollDelta,
                                    float scaleFactor);
   virtual WebKit::WebGraphicsContext3D* createContext3D();
   virtual void didRebindGraphicsContext(bool success);
   virtual void didCommitAndDrawFrame();
   virtual void didCompleteSwapBuffers();
   virtual void scheduleComposite();
@@ skipping 16 matching lines @@
   ObserverList<CompositorObserver> observer_list_;
 
   gfx::AcceleratedWidget widget_;
   WebKit::WebLayer root_web_layer_;
   WebKit::WebLayerTreeView host_;
 
   // This is set to true when the swap buffers has been posted and we're waiting
   // for completion.
   bool swap_posted_;
 
+  float device_scale_factor_;
+
+  // Transforms to scale the translation in |transform_|.
+  Transform scale_translate_;
+  Transform invese_scale_translate_;

[piman, 2012/05/04 18:46:06]

nit: invese->inverse

+
   friend class base::RefCounted<Compositor>;
 };
 
 }  // namespace ui
 
 #endif  // UI_GFX_COMPOSITOR_COMPOSITOR_H_