FlutterThreadSynchronizerTest.mm File Reference

#import "flutter/shell/platform/darwin/macos/framework/Source/FlutterThreadSynchronizer.h"
#import "flutter/fml/synchronization/waitable_event.h"
#import "flutter/testing/testing.h"

Go to the source code of this file.

Classes
class	FlutterThreadSynchronizerTestScaffold

Functions
	TEST (FlutterThreadSynchronizerTest, RegularCommit)
	TEST (FlutterThreadSynchronizerTest, ResizingBlocksRenderingUntilSizeMatches)
	TEST (FlutterThreadSynchronizerTest, ShutdownMakesEverythingNonBlocking)
	TEST (FlutterThreadSynchronizerTest, RegularCommitForMultipleViews)
	TEST (FlutterThreadSynchronizerTest, ResizingForMultipleViews)

Variables
std::shared_ptr< fml::AutoResetWaitableEvent >	_mainLatch
dispatch_queue_t	_renderQueue
std::shared_ptr< fml::AutoResetWaitableEvent >	_renderLatch
FlutterThreadSynchronizer *	_synchronizer

Function Documentation

TEST() [1/5]

TEST	(	FlutterThreadSynchronizerTest	,
		RegularCommit
	)

Definition at line 71 of file FlutterThreadSynchronizerTest.mm.

                                                   {
  FlutterThreadSynchronizerTestScaffold* scaffold =
      [[FlutterThreadSynchronizerTestScaffold alloc] init];
  FlutterThreadSynchronizer* synchronizer = scaffold.synchronizer;
 
  // Initial resize: does not block until the first frame.
  __block int notifiedResize = 0;
  [scaffold dispatchMainTask:^{
    [synchronizer registerView:1];
    [synchronizer beginResizeForView:1
                                size:CGSize{5, 5}
                              notify:^{
                                notifiedResize += 1;
                              }];
  }];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
  [scaffold joinMain];
  EXPECT_EQ(notifiedResize, 1);
 
  // Still does not block.
  [scaffold dispatchMainTask:^{
    [synchronizer beginResizeForView:1
                                size:CGSize{7, 7}
                              notify:^{
                                notifiedResize += 1;
                              }];
  }];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
  [scaffold joinMain];
  EXPECT_EQ(notifiedResize, 2);
 
  // First frame
  __block int notifiedCommit = 0;
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{7, 7}
                                notify:^{
                                  notifiedCommit += 1;
                                }];
  }];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
  [scaffold joinRender];
  EXPECT_EQ(notifiedCommit, 1);
}

TEST() [2/5]

TEST	(	FlutterThreadSynchronizerTest	,
		RegularCommitForMultipleViews
	)

Definition at line 236 of file FlutterThreadSynchronizerTest.mm.

                                                                   {
  FlutterThreadSynchronizerTestScaffold* scaffold =
      [[FlutterThreadSynchronizerTestScaffold alloc] init];
  FlutterThreadSynchronizer* synchronizer = scaffold.synchronizer;
  fml::AutoResetWaitableEvent begunResizingLatch;
  fml::AutoResetWaitableEvent* begunResizing = &begunResizingLatch;
 
  // Initial resize: does not block until the first frame.
  [scaffold dispatchMainTask:^{
    [synchronizer registerView:1];
    [synchronizer registerView:2];
    [synchronizer beginResizeForView:1
                                size:CGSize{5, 5}
                              notify:^{
                              }];
    [synchronizer beginResizeForView:2
                                size:CGSize{15, 15}
                              notify:^{
                                begunResizing->Signal();
                              }];
  }];
  begunResizing->Wait();
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
  [scaffold joinMain];
 
  // Still does not block.
  [scaffold dispatchMainTask:^{
    [synchronizer beginResizeForView:1
                                size:CGSize{7, 7}
                              notify:^{
                                begunResizing->Signal();
                              }];
  }];
  begunResizing->Signal();
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
  [scaffold joinMain];
 
  // First frame
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{7, 7}
                                notify:^{
                                }];
    [synchronizer performCommitForView:2
                                  size:CGSize{15, 15}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
}

TEST() [3/5]

TEST	(	FlutterThreadSynchronizerTest	,
		ResizingBlocksRenderingUntilSizeMatches
	)

Definition at line 116 of file FlutterThreadSynchronizerTest.mm.

                                                                             {
  FlutterThreadSynchronizerTestScaffold* scaffold =
      [[FlutterThreadSynchronizerTestScaffold alloc] init];
  FlutterThreadSynchronizer* synchronizer = scaffold.synchronizer;
  // A latch to ensure that a beginResizeForView: call has at least executed
  // something, so that the isWaitingWhenMutexIsAvailable: call correctly stops
  // at either when beginResizeForView: finishes or waits half way.
  fml::AutoResetWaitableEvent begunResizingLatch;
  fml::AutoResetWaitableEvent* begunResizing = &begunResizingLatch;
 
  // Initial resize: does not block until the first frame.
  [scaffold dispatchMainTask:^{
    [synchronizer registerView:1];
    [synchronizer beginResizeForView:1
                                size:CGSize{5, 5}
                              notify:^{
                              }];
  }];
  [scaffold joinMain];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // First frame.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{5, 5}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Resize to (7, 7): blocks until the next frame.
  [scaffold dispatchMainTask:^{
    [synchronizer beginResizeForView:1
                                size:CGSize{7, 7}
                              notify:^{
                                begunResizing->Signal();
                              }];
  }];
  begunResizing->Wait();
  EXPECT_TRUE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Render with old size.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{5, 5}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_TRUE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Render with new size.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{7, 7}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  [scaffold joinMain];
}

TEST() [4/5]

TEST	(	FlutterThreadSynchronizerTest	,
		ResizingForMultipleViews
	)

Definition at line 288 of file FlutterThreadSynchronizerTest.mm.

                                                              {
  FlutterThreadSynchronizerTestScaffold* scaffold =
      [[FlutterThreadSynchronizerTestScaffold alloc] init];
  FlutterThreadSynchronizer* synchronizer = scaffold.synchronizer;
  fml::AutoResetWaitableEvent begunResizingLatch;
  fml::AutoResetWaitableEvent* begunResizing = &begunResizingLatch;
 
  // Initial resize: does not block until the first frame.
  [scaffold dispatchMainTask:^{
    [synchronizer registerView:1];
    [synchronizer registerView:2];
    [synchronizer beginResizeForView:1
                                size:CGSize{5, 5}
                              notify:^{
                              }];
    [synchronizer beginResizeForView:2
                                size:CGSize{15, 15}
                              notify:^{
                              }];
  }];
  [scaffold joinMain];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // First frame.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{5, 5}
                                notify:^{
                                }];
    [synchronizer performCommitForView:2
                                  size:CGSize{15, 15}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Resize view 2 to (17, 17): blocks until the next frame.
  [scaffold dispatchMainTask:^{
    [synchronizer beginResizeForView:2
                                size:CGSize{17, 17}
                              notify:^{
                                begunResizing->Signal();
                              }];
  }];
  begunResizing->Wait();
  EXPECT_TRUE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Render view 1 with the size. Still blocking.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{5, 5}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_TRUE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Render view 2 with the old size. Still blocking.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{15, 15}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_TRUE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Render view 1 with the size.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{5, 5}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_TRUE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Render view 2 with the new size. Unblocks.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:2
                                  size:CGSize{17, 17}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  [scaffold joinMain];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
}

TEST() [5/5]

TEST	(	FlutterThreadSynchronizerTest	,
		ShutdownMakesEverythingNonBlocking
	)

Definition at line 181 of file FlutterThreadSynchronizerTest.mm.

                                                                        {
  FlutterThreadSynchronizerTestScaffold* scaffold =
      [[FlutterThreadSynchronizerTestScaffold alloc] init];
  FlutterThreadSynchronizer* synchronizer = scaffold.synchronizer;
  fml::AutoResetWaitableEvent begunResizingLatch;
  fml::AutoResetWaitableEvent* begunResizing = &begunResizingLatch;
 
  // Initial resize
  [scaffold dispatchMainTask:^{
    [synchronizer registerView:1];
    [synchronizer beginResizeForView:1
                                size:CGSize{5, 5}
                              notify:^{
                              }];
  }];
  [scaffold joinMain];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  // Push a frame.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{5, 5}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
 
  [scaffold dispatchMainTask:^{
    [synchronizer shutdown];
  }];
 
  // Resize to (7, 7). Should not block any frames since it has shut down.
  [scaffold dispatchMainTask:^{
    [synchronizer beginResizeForView:1
                                size:CGSize{7, 7}
                              notify:^{
                                begunResizing->Signal();
                              }];
  }];
  begunResizing->Wait();
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
  [scaffold joinMain];
 
  // All further calls should be unblocking.
  [scaffold dispatchRenderTask:^{
    [synchronizer performCommitForView:1
                                  size:CGSize{9, 9}
                                notify:^{
                                }];
  }];
  [scaffold joinRender];
  EXPECT_FALSE([synchronizer isWaitingWhenMutexIsAvailable]);
}

Variable Documentation

_mainLatch

std::shared_ptr<fml::AutoResetWaitableEvent> _mainLatch

Initial value:

{
  dispatch_queue_t _mainQueue

Definition at line 23 of file FlutterThreadSynchronizerTest.mm.

_renderLatch

std::shared_ptr<fml::AutoResetWaitableEvent> _renderLatch

Definition at line 26 of file FlutterThreadSynchronizerTest.mm.

_renderQueue

dispatch_queue_t _renderQueue

Definition at line 25 of file FlutterThreadSynchronizerTest.mm.

_synchronizer

FlutterThreadSynchronizer* _synchronizer

Definition at line 28 of file FlutterThreadSynchronizerTest.mm.