Implements core logic for Pixel Canvas

ui/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_COMPOSITOR_COMPOSITOR_H_
 #define UI_COMPOSITOR_COMPOSITOR_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 176 matching lines @@
     : NON_EXPORTED_BASE(public cc::LayerTreeHostClient),
       NON_EXPORTED_BASE(public cc::LayerTreeHostSingleThreadClient),
       NON_EXPORTED_BASE(public CompositorLockDelegate),
       NON_EXPORTED_BASE(public viz::HostFrameSinkClient) {
  public:
   Compositor(const viz::FrameSinkId& frame_sink_id,
              ui::ContextFactory* context_factory,
              ui::ContextFactoryPrivate* context_factory_private,
              scoped_refptr<base::SingleThreadTaskRunner> task_runner,
              bool enable_surface_synchronization,
+             bool enable_pixel_canvas,
              bool external_begin_frames_enabled = false);
   ~Compositor() override;
 
   ui::ContextFactory* context_factory() { return context_factory_; }
 
   ui::ContextFactoryPrivate* context_factory_private() {
     return context_factory_private_;
   }
 
   void AddFrameSink(const viz::FrameSinkId& frame_sink_id);
@@ skipping 191 matching lines @@
   }
 
   const viz::FrameSinkId& frame_sink_id() const { return frame_sink_id_; }
   int activated_frame_count() const { return activated_frame_count_; }
   float refresh_rate() const { return refresh_rate_; }
 
   void set_allow_locks_to_extend_timeout(bool allowed) {
     allow_locks_to_extend_timeout_ = allowed;
   }
 
+  // If true, all paint commands are recorded at pixel size instead of DIP.
+  bool is_pixel_canvas() const { return is_pixel_canvas_; }
+
  private:
   friend class base::RefCounted<Compositor>;
 
   // CompositorLockDelegate implementation.
   void RemoveCompositorLock(CompositorLock* lock) override;
 
   // Causes all active CompositorLocks to be timed out.
   void TimeoutLocks();
 
   gfx::Size size_;
@@ skipping 44 matching lines @@
   scoped_refptr<cc::AnimationTimeline> animation_timeline_;
   std::unique_ptr<ScopedAnimationDurationScaleMode> slow_animations_;
 
   gfx::ColorSpace output_color_space_;
   gfx::ColorSpace blending_color_space_;
 
   // The estimated time that the locks will timeout.
   base::TimeTicks scheduled_timeout_;
   // If true, the |scheduled_timeout_| might be recalculated and extended.
   bool allow_locks_to_extend_timeout_;
+  // If true, all paint commands are recorded at pixel size instead of DIP.
+  const bool is_pixel_canvas_;
 
   base::WeakPtrFactory<Compositor> weak_ptr_factory_;
   base::WeakPtrFactory<Compositor> lock_timeout_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_