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 23 matching lines @@
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
 const double kDefaultRefreshRate = 60.0;
 const double kTestRefreshRate = 200.0;
 
 }  // namespace
 
 namespace ui {
+// ResizeSwapPromise is used to track the progression of a frame of a given size
+// through commit/draw/post. Once complete, this class updates Compositor's
+// pending swapped frame size.
+class Compositor::ResizeSwapPromise : public cc::SwapPromise {
+ public:
+  ResizeSwapPromise(Compositor* compositor, const gfx::Size& pending_size)
+      : compositor_(compositor), pending_size_(pending_size) {}
+  ~ResizeSwapPromise() override {}
+
+  // cc::SwapPromise implementation:
+  void DidActivate() override {}
+  void DidNotSwap(DidNotSwapReason reason) override {}
+  void DidSwap(cc::CompositorFrameMetadata* metadata) override {
+    // This will come in on the impl thread - schedule the update on the main
+    // thread.

[piman, 2015/12/15 07:15:36]

We have only one thread on the browser side now, so no need to post the task.

Actually you probably don't want to post the task, otherwise you could have a
race where the swap buffer callback arrives before you got a chance to execute
this task.

+    compositor_->task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&Compositor::set_pending_swapped_frame_size,
+                   compositor_->weak_ptr_factory_.GetWeakPtr(), pending_size_));
+  }
+  virtual int64 TraceId() const { return 0; }
+
+ private:
+  Compositor* compositor_;
+  gfx::Size pending_size_;
+};
 
 CompositorLock::CompositorLock(Compositor* compositor)
     : compositor_(compositor) {
   if (compositor_->locks_will_time_out_) {
     compositor_->task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
         base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
   }
 }
@@ skipping 220 matching lines @@
   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()) {
     size_ = size_in_pixel;
     host_->SetViewportSize(size_in_pixel);
     root_web_layer_->SetBounds(size_in_pixel);
     context_factory_->ResizeDisplay(this, size_in_pixel);
+
+    scoped_ptr<ResizeSwapPromise> resize_swap_promise(
+        new ResizeSwapPromise(this, size_in_pixel));
+    host_->QueueSwapPromise(resize_swap_promise.Pass());
   }
   if (device_scale_factor_ != scale) {
     device_scale_factor_ = scale;
     host_->SetDeviceScaleFactor(scale);
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
   }
 }
 
 void Compositor::SetBackgroundColor(SkColor color) {
@@ skipping 145 matching lines @@
 
 void Compositor::DidCompleteSwapBuffers() {
   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));
+
+  // Enqueue the last_swapped update on our task runner. to ensure ordering with
+  // relation to the ResizeSwapPromise's call to set_pending_swapped_size.
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Compositor::UpdateLastSwappedFrameSize,
+                            weak_ptr_factory_.GetWeakPtr()));

[piman, 2015/12/15 07:15:35]

You don't need to post the task any more (see above).

 }
 
 void Compositor::DidAbortSwapBuffers() {
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingAborted(this));
 }
 
 void Compositor::SendBeginFramesToChildren(const cc::BeginFrameArgs& args) {
   FOR_EACH_OBSERVER(CompositorBeginFrameObserver, begin_frame_observer_list_,
@@ skipping 45 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui