ui: Rework CompositorResizeLock interaction with DelegatedFrameHost

content/browser/renderer_host/render_widget_host_view_aura_unittest.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <tuple>
@@ skipping 337 matching lines @@
   size_t GetAndResetProcessedTouchEventCount() {
     size_t count = processed_touch_event_count_;
     processed_touch_event_count_ = 0;
     return count;
   }
 
  private:
   size_t processed_touch_event_count_;
 };
 
-class FakeDelegatedFrameHostClientAura : public DelegatedFrameHostClientAura {
+class FakeDelegatedFrameHostClientAura : public DelegatedFrameHostClientAura,
+                                         public ui::CompositorLockDelegate {
  public:
   explicit FakeDelegatedFrameHostClientAura(
       RenderWidgetHostViewAura* render_widget_host_view)
-      : DelegatedFrameHostClientAura(render_widget_host_view) {}
+      : DelegatedFrameHostClientAura(render_widget_host_view),
+        weak_ptr_factory_(this) {}
   ~FakeDelegatedFrameHostClientAura() override = default;
 
   void DisableResizeLock() { can_create_resize_lock_ = false; }
 
+  bool resize_locked() const { return resize_locked_; }
+  bool compositor_locked() const { return compositor_locked_; }
+
  private:
   // DelegatedFrameHostClientAura implementation.
   bool DelegatedFrameCanCreateResizeLock() const override {
     return can_create_resize_lock_;
   }
 
   // CompositorResizeLockClient implemention. Overrides from
   // DelegatedFrameHostClientAura, to prevent the lock from timing out.
   std::unique_ptr<ui::CompositorLock> GetCompositorLock(
       ui::CompositorLockClient* client) override {
-    return base::MakeUnique<ui::CompositorLock>(nullptr, nullptr);
+    resize_locked_ = compositor_locked_ = true;
+    return base::MakeUnique<ui::CompositorLock>(nullptr,
+                                                weak_ptr_factory_.GetWeakPtr());
+  }
+  // CompositorResizeLockClient implemention. Overrides from
+  // // DelegatedFrameHostClientAura.
+  void CompositorResizeLockEnded() override {
+    resize_locked_ = false;
+    DelegatedFrameHostClientAura::CompositorResizeLockEnded();
+  }
+
+  // ui::CompositorLockDelegate implemention.
+  void RemoveCompositorLock(ui::CompositorLock*) override {
+    compositor_locked_ = false;
   }
 
   bool can_create_resize_lock_ = true;
+  bool resize_locked_ = false;
+  bool compositor_locked_ = false;
+  base::WeakPtrFactory<FakeDelegatedFrameHostClientAura> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDelegatedFrameHostClientAura);
 };
 
 class FakeRenderWidgetHostViewAura : public RenderWidgetHostViewAura {
  public:
   FakeRenderWidgetHostViewAura(RenderWidgetHost* widget,
                                bool is_guest_view_hack)
       : RenderWidgetHostViewAura(widget, is_guest_view_hack),
         delegated_frame_host_client_(
@@ skipping 44 matching lines @@
   bool released_front_lock_active() const {
     return GetDelegatedFrameHost()->ReleasedFrontLockActiveForTesting();
   }
 
   void ReclaimResources(const cc::ReturnedResourceArray& resources) {
     GetDelegatedFrameHost()->ReclaimResources(resources);
   }
 
   void ResetCompositor() { GetDelegatedFrameHost()->ResetCompositor(); }
 
-  const ui::MotionEventAura& pointer_state_for_test() {
+  const ui::MotionEventAura& pointer_state() {
     return event_handler()->pointer_state();
   }
 
+  bool resize_locked() const {
+    return delegated_frame_host_client_->resize_locked();
+  }
+  bool compositor_locked() const {
+    return delegated_frame_host_client_->compositor_locked();
+  }
+
   gfx::Size last_frame_size_;
   std::unique_ptr<cc::CopyOutputRequest> last_copy_request_;
   FakeWindowEventDispatcher* dispatcher_;
 
  private:
   FakeDelegatedFrameHostClientAura* delegated_frame_host_client_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeRenderWidgetHostViewAura);
 };
 
@@ skipping 213 matching lines @@
 
     InputEventDispatchType dispatch_type = std::get<3>(params);
     if (dispatch_type == InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)
       return;
 
     const blink::WebInputEvent* event = std::get<0>(params);
     SendTouchEventACK(event->type(), ack_result,
                       WebInputEventTraits::GetUniqueTouchEventId(*event));
   }
 
-  const ui::MotionEventAura& pointer_state() {
-    return view_->pointer_state_for_test();
-  }
+  const ui::MotionEventAura& pointer_state() { return view_->pointer_state(); }
 
   void EnableRafAlignedTouchInput() {
     feature_list_.InitFromCommandLine(
         features::kRafAlignedTouchInputEvents.name, "");
   }
 
   void DisableRafAlignedTouchInput() {
     feature_list_.InitFromCommandLine(
         "", features::kRafAlignedTouchInputEvents.name);
   }
@@ skipping 1587 matching lines @@
   // A partial damage frame.
   gfx::Rect partial_view_rect(30, 30, 20, 20);
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, partial_view_rect));
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
+  EXPECT_FALSE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
+
   // Lock the compositor. Now we should drop frames.
   view_rect = gfx::Rect(150, 150);
   view_->SetSize(view_rect.size());
+  EXPECT_TRUE(view_->resize_locked());
+  EXPECT_TRUE(view_->compositor_locked());
 
   // This frame is dropped.
   gfx::Rect dropped_damage_rect_1(10, 20, 30, 40);
   EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, dropped_damage_rect_1));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   gfx::Rect dropped_damage_rect_2(40, 50, 10, 20);
   EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, dropped_damage_rect_2));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
+  EXPECT_TRUE(view_->resize_locked());
+  EXPECT_TRUE(view_->compositor_locked());
+
   // Unlock the compositor. This frame should damage everything.
   frame_size = view_rect.size();
 
   gfx::Rect new_damage_rect(5, 6, 10, 10);
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, new_damage_rect));
+  // The swap unlocks the compositor.
+  EXPECT_TRUE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
   testing::Mock::VerifyAndClearExpectations(&observer);
+  // The UI commit unlocks for further resize.
   view_->RunOnCompositingDidCommit();
+  EXPECT_FALSE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
 
   // A partial damage frame, this should not be dropped.
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, partial_view_rect));
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
+  EXPECT_FALSE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
 
-
-  // Resize to something empty.
+  // Resize to something empty. This doesn't lock anything since it's not
+  // visible anymore anyways.
   view_rect = gfx::Rect(100, 0);
   view_->SetSize(view_rect.size());
+  EXPECT_FALSE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
 
   // We're never expecting empty frames, resize to something non-empty.
   view_rect = gfx::Rect(100, 100);
   view_->SetSize(view_rect.size());
+  EXPECT_TRUE(view_->resize_locked());
+  EXPECT_TRUE(view_->compositor_locked());
 
   // This frame should not be dropped.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, view_rect.size(), view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
+  EXPECT_TRUE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
   view_->RunOnCompositingDidCommit();
+  EXPECT_FALSE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
 
   view_->window_->RemoveObserver(&observer);
 }
+
+// If resize races with a renderer frame, we should lock for the right size.
+TEST_F(RenderWidgetHostViewAuraTest, ResizeAfterReceivingFrame) {
+  gfx::Rect view_rect(100, 100);
+  gfx::Size frame_size = view_rect.size();
+
+  view_->InitAsChild(nullptr);
+  aura::client::ParentWindowWithContext(
+      view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
+      gfx::Rect());
+  view_->SetSize(view_rect.size());
+
+  MockWindowObserver observer;
+  view_->window_->AddObserver(&observer);
+
+  // A frame of initial size.
+  EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
+      MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
+  testing::Mock::VerifyAndClearExpectations(&observer);
+  view_->RunOnCompositingDidCommit();
+
+  // A frame of initial size arrives, but we don't commit in the UI yet.
+  EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, _));
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
+      MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
+  testing::Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_FALSE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
+
+  // Resize, and lock the compositor. Now we should drop frames of the old size.
+  view_rect = gfx::Rect(150, 150);
+  view_->SetSize(view_rect.size());
+  EXPECT_TRUE(view_->resize_locked());
+  EXPECT_TRUE(view_->compositor_locked());
+
+  EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
+      MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
+  testing::Mock::VerifyAndClearExpectations(&observer);
+
+  // If the CompositorLock times out in the meantime, a commit would happen.
+  // Verify that if a commit occurs, the lock remains and we reject frames
+  // of the wrong size still.
+  view_->RunOnCompositingDidCommit();
+
+  EXPECT_TRUE(view_->resize_locked());
+  // In this case we lied about it and the CompositorLock is still active.
+  EXPECT_TRUE(view_->compositor_locked());
+
+  EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
+      MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
+  testing::Mock::VerifyAndClearExpectations(&observer);
+
+  // A frame arrives of the new size, which will be accepted.
+  frame_size = view_rect.size();
+  EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, _));
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
+      MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
+  // Receiving the frame unlocks the compositor so it can commit.
+  EXPECT_TRUE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
+  testing::Mock::VerifyAndClearExpectations(&observer);
+
+  // When the frame of the correct size is committed, the CompositorResizeLock
+  // is released.
+  view_->RunOnCompositingDidCommit();
+  EXPECT_FALSE(view_->resize_locked());
+  EXPECT_FALSE(view_->compositor_locked());
+
+  view_->window_->RemoveObserver(&observer);
+}
 
 TEST_F(RenderWidgetHostViewAuraTest, OutputSurfaceIdChange) {
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
@@ skipping 60 matching lines @@
 
   // Create a bunch of renderers.
   for (size_t i = 0; i < renderer_count; ++i) {
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     hosts[i] = new RenderWidgetHostImpl(delegates_.back().get(), process_host_,
                                         routing_id, false);
     delegates_.back()->set_widget_host(hosts[i]);
     hosts[i]->Init();
     views[i] = new FakeRenderWidgetHostViewAura(hosts[i], false);
+    // Prevent frames from being skipped due to resize, this test does not
+    // run a UI compositor so the DelegatedFrameHost doesn't get the chance
+    // to release its resize lock once it receives a frame of the expected
+    // size.
+    views[i]->DisableResizeLock();
     views[i]->InitAsChild(nullptr);
     aura::client::ParentWindowWithContext(
         views[i]->GetNativeView(),
         parent_view_->GetNativeView()->GetRootWindow(),
         gfx::Rect());
     views[i]->SetSize(view_rect.size());
   }
 
   // Make each renderer visible, and swap a frame on it, then make it invisible.
   for (size_t i = 0; i < renderer_count; ++i) {
@@ skipping 2648 matching lines @@
     // There is no composition in the beginning.
     EXPECT_FALSE(has_composition_text());
     SetHasCompositionTextToTrue();
     view->ImeCancelComposition();
     // The composition must have been canceled.
     EXPECT_FALSE(has_composition_text());
   }
 }
 
 }  // namespace content