Implements core logic for Pixel Canvas

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 39 matching lines @@
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/switches.h"
 #include "ui/gl/gl_switches.h"
 
 namespace ui {
 
 Compositor::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_surface_synchronization,
+                       bool enable_pixel_canvas)
     : context_factory_(context_factory),
       context_factory_private_(context_factory_private),
       frame_sink_id_(frame_sink_id),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       layer_animator_collection_(this),
       scheduled_timeout_(base::TimeTicks()),
       allow_locks_to_extend_timeout_(false),
+      is_pixel_canvas_(enable_pixel_canvas),
       weak_ptr_factory_(this),
       lock_timeout_weak_ptr_factory_(this) {
   if (context_factory_private) {
     context_factory_private->GetFrameSinkManager()
         ->surface_manager()
         ->RegisterFrameSinkId(frame_sink_id_);
   }
   root_web_layer_ = cc::Layer::Create();
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
@@ skipping 239 matching lines @@
     size_ = size_in_pixel;
     host_->SetViewportSize(size_in_pixel);
     root_web_layer_->SetBounds(size_in_pixel);
     // TODO(fsamuel): Get rid of ContextFactoryPrivate.
     if (context_factory_private_)
       context_factory_private_->ResizeDisplay(this, size_in_pixel);
   }
   if (device_scale_factor_ != scale) {
     device_scale_factor_ = scale;
     host_->SetDeviceScaleFactor(scale);
+    if (is_pixel_canvas())
+      host_->SetRecordingScaleFactor(scale);
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
   }
 }
 
 void Compositor::SetDisplayColorSpace(const gfx::ColorSpace& color_space) {
   blending_color_space_ = color_space;
   output_color_space_ = blending_color_space_;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableHDR)) {
     blending_color_space_ = gfx::ColorSpace::CreateExtendedSRGB();
@@ skipping 249 matching lines @@
 void Compositor::TimeoutLocks() {
   // Make a copy, we're going to cause |active_locks_| to become
   // empty.
   std::vector<CompositorLock*> locks = active_locks_;
   for (auto* lock : locks)
     lock->TimeoutLock();
   DCHECK(active_locks_.empty());
 }
 
 }  // namespace ui