WIP - Gutterless resize on Windows

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 <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 61 matching lines @@
       output_surface_requested_(false),
       surface_id_allocator_(context_factory->CreateSurfaceIdAllocator()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       locks_will_time_out_(true),
       compositor_lock_(NULL),
       layer_animator_collection_(this),
+      has_swapped_frame_at_current_size_(false),
       weak_ptr_factory_(this) {
   root_web_layer_ = cc::Layer::Create(Layer::UILayerSettings());
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
 
   // This will ensure PictureLayers always can have LCD text, to match the
   // previous behaviour with ContentLayers, where LCD-not-allowed notifications
   // were ignored.
@@ skipping 178 matching lines @@
 
 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
   scoped_ptr<cc::SwapPromise> swap_promise(
       new cc::LatencyInfoSwapPromise(latency_info));
   host_->QueueSwapPromise(swap_promise.Pass());
 }
 
 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
   DCHECK_GT(scale, 0);
   if (!size_in_pixel.IsEmpty()) {
+    if (size_ != size_in_pixel) {
+      has_swapped_frame_at_current_size_ = false;
+    }
+
     size_ = size_in_pixel;
     host_->SetViewportSize(size_in_pixel);
     root_web_layer_->SetBounds(size_in_pixel);
     context_factory_->ResizeDisplay(this, size_in_pixel);
   }
   if (device_scale_factor_ != scale) {
     device_scale_factor_ = scale;
     host_->SetDeviceScaleFactor(scale);
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
@@ skipping 141 matching lines @@
   DCHECK(!IsLocked());
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingDidCommit(this));
 }
 
 void Compositor::DidCommitAndDrawFrame() {
 }
 
 void Compositor::DidCompleteSwapBuffers() {
+  has_swapped_frame_at_current_size_ = true;

[piman, 2015/12/11 07:53:12]

It is possible that the main thread will start the next frame before it received
the SwapBuffers ack (e.g. if the GPU process is under load). If that happens, it
could be that SetScaleAndSize is called again before this is called, in which
case it wouldn't be appropriate to set this to true. We could also have multiple
frames in the pipeline.

You'd want to track the size as it goes through the compositor steps. After you
set the size you need all of these to happen:
- commit
- draw frame
- post swap
- complete swap

you only got a "correct" frame if SetScaleAndSize wasn't called between any of
these steps. You can either track that manually (e.g. have a state enum, that
gets advanced in each of the relevant callbacks, and reset in SetScaleAndSize),
or using a SwapPromise which will track the first 3 for you.

[ericrk, 2015/12/15 00:25:03]

Good feedback - I've updated this to use a SwapPromise to track most of this.
Let me know how the new version looks. 

   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
                     OnCompositingEnded(this));
 }
 
 void Compositor::DidPostSwapBuffers() {
   base::TimeTicks start_time = base::TimeTicks::Now();
   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
                     OnCompositingStarted(this, start_time));
 }
 
@@ skipping 53 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui