#include <raster_thread_merger.h>

Inheritance diagram for fml::RasterThreadMerger:

Public Member Functions
void	MergeWithLease (size_t lease_term)

const fml::RefPtr< SharedThreadMerger > &	GetSharedRasterThreadMerger () const

void	UnMergeNowIfLastOne ()

void	ExtendLeaseTo (size_t lease_term)

RasterThreadStatus	DecrementLease ()

bool	IsMerged ()

void	WaitUntilMerged ()

bool	IsOnRasterizingThread ()

bool	IsOnPlatformThread () const

void	Enable ()

void	Disable ()

bool	IsEnabled ()

void	SetMergeUnmergeCallback (const fml::closure &callback)

Public Member Functions inherited from fml::RefCountedThreadSafe< RasterThreadMerger >
void	Release () const

Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void	AddRef () const

bool	HasOneRef () const

void	AssertHasOneRef () const

Static Public Member Functions
static fml::RefPtr< fml::RasterThreadMerger >	CreateOrShareThreadMerger (const fml::RefPtr< fml::RasterThreadMerger > &parent_merger, TaskQueueId platform_id, TaskQueueId raster_id)

Additional Inherited Members
Protected Member Functions inherited from fml::RefCountedThreadSafe< RasterThreadMerger >
	RefCountedThreadSafe ()

	~RefCountedThreadSafe ()

Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
	RefCountedThreadSafeBase ()

	~RefCountedThreadSafeBase ()

bool	Release () const

void	Adopt ()

Detailed Description

Definition at line 31 of file raster_thread_merger.h.

Member Function Documentation

◆ CreateOrShareThreadMerger()

fml::RefPtr< fml::RasterThreadMerger > fml::RasterThreadMerger::CreateOrShareThreadMerger	(	const fml::RefPtr< fml::RasterThreadMerger > &	parent_merger,
		TaskQueueId	platform_id,
		TaskQueueId	raster_id
	)

static

Creates a new merger from parent, share the inside shared_merger member when the platform_queue_id and raster_queue_id are same, otherwise create a new shared_merger instance

Definition at line 40 of file raster_thread_merger.cc.

                           {
  if (parent_merger && parent_merger->platform_queue_id_ == platform_id &&
      parent_merger->gpu_queue_id_ == raster_id) {
    auto shared_merger = parent_merger->GetSharedRasterThreadMerger();
    return fml::MakeRefCounted<RasterThreadMerger>(shared_merger, platform_id,
                                                   raster_id);
  } else {
    return fml::MakeRefCounted<RasterThreadMerger>(platform_id, raster_id);
  }
}

Referenced by flutter::Rasterizer::Setup(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), and fml::testing::TEST().

◆ DecrementLease()

RasterThreadStatus fml::RasterThreadMerger::DecrementLease ( )

Definition at line 159 of file raster_thread_merger.cc.

                                                      {
  if (TaskQueuesAreSame()) {
    return RasterThreadStatus::kRemainsMerged;
  }
  std::scoped_lock lock(mutex_);
  if (!IsMergedUnSafe()) {
    return RasterThreadStatus::kRemainsUnmerged;
  }
  if (!IsEnabledUnSafe()) {
    return RasterThreadStatus::kRemainsMerged;
  }
  bool unmerged_after_decrement = shared_merger_->DecrementLease(this);
  if (unmerged_after_decrement) {
    if (merge_unmerge_callback_ != nullptr) {
      merge_unmerge_callback_();
    }
    return RasterThreadStatus::kUnmergedNow;
  }
 
  return RasterThreadStatus::kRemainsMerged;
}

References fml::SharedThreadMerger::DecrementLease(), fml::kRemainsMerged, fml::kRemainsUnmerged, and fml::kUnmergedNow.

◆ Disable()

void fml::RasterThreadMerger::Disable ( )

Definition at line 128 of file raster_thread_merger.cc.

                                 {
  std::scoped_lock lock(mutex_);
  shared_merger_->SetEnabledUnSafe(false);
}

References fml::SharedThreadMerger::SetEnabledUnSafe().

Referenced by flutter::Rasterizer::DisableThreadMergerIfNeeded().

◆ Enable()

void fml::RasterThreadMerger::Enable ( )

Definition at line 123 of file raster_thread_merger.cc.

                                {
  std::scoped_lock lock(mutex_);
  shared_merger_->SetEnabledUnSafe(true);
}

References fml::SharedThreadMerger::SetEnabledUnSafe().

Referenced by flutter::Rasterizer::EnableThreadMergerIfNeeded().

◆ ExtendLeaseTo()

void fml::RasterThreadMerger::ExtendLeaseTo ( size_t lease_term )

Definition at line 106 of file raster_thread_merger.cc.

                                                        {
  FML_DCHECK(lease_term > 0) << "lease_term should be positive.";
  if (TaskQueuesAreSame()) {
    return;
  }
  std::scoped_lock lock(mutex_);
  if (!IsEnabledUnSafe()) {
    return;
  }
  shared_merger_->ExtendLeaseTo(this, lease_term);
}

References fml::SharedThreadMerger::ExtendLeaseTo(), and FML_DCHECK.

◆ GetSharedRasterThreadMerger()

const fml::RefPtr< fml::SharedThreadMerger > & fml::RasterThreadMerger::GetSharedRasterThreadMerger ( ) const

Definition at line 35 of file raster_thread_merger.cc.

                                                      {
  return shared_merger_;
}

◆ IsEnabled()

bool fml::RasterThreadMerger::IsEnabled ( )

Definition at line 133 of file raster_thread_merger.cc.

                                   {
  std::scoped_lock lock(mutex_);
  return IsEnabledUnSafe();
}

Referenced by flutter::Rasterizer::Teardown().

◆ IsMerged()

bool fml::RasterThreadMerger::IsMerged ( )

Definition at line 118 of file raster_thread_merger.cc.

                                  {
  std::scoped_lock lock(mutex_);
  return IsMergedUnSafe();
}

Referenced by flutter::Rasterizer::Teardown().

◆ IsOnPlatformThread()

bool fml::RasterThreadMerger::IsOnPlatformThread ( ) const

Definition at line 92 of file raster_thread_merger.cc.

                                                  {
  return MessageLoop::GetCurrentTaskQueueId() == platform_queue_id_;
}

References fml::MessageLoop::GetCurrentTaskQueueId().

Referenced by IsOnRasterizingThread(), and WaitUntilMerged().

◆ IsOnRasterizingThread()

bool fml::RasterThreadMerger::IsOnRasterizingThread ( )

Definition at line 96 of file raster_thread_merger.cc.

                                               {
  std::scoped_lock lock(mutex_);
 
  if (IsMergedUnSafe()) {
    return IsOnPlatformThread();
  } else {
    return !IsOnPlatformThread();
  }
}

References IsOnPlatformThread().

Referenced by flutter::Rasterizer::Draw().

◆ MergeWithLease()

void fml::RasterThreadMerger::MergeWithLease ( size_t lease_term )

Definition at line 54 of file raster_thread_merger.cc.

                                                         {
  std::scoped_lock lock(mutex_);
  if (TaskQueuesAreSame()) {
    return;
  }
  if (!IsEnabledUnSafe()) {
    return;
  }
  FML_DCHECK(lease_term > 0) << "lease_term should be positive.";
 
  if (IsMergedUnSafe()) {
    merged_condition_.notify_one();
    return;
  }
 
  bool success = shared_merger_->MergeWithLease(this, lease_term);
  if (success && merge_unmerge_callback_ != nullptr) {
    merge_unmerge_callback_();
  }
 
  merged_condition_.notify_one();
}

References FML_DCHECK, and fml::SharedThreadMerger::MergeWithLease().

◆ SetMergeUnmergeCallback()

void fml::RasterThreadMerger::SetMergeUnmergeCallback ( const fml::closure & callback )

Definition at line 30 of file raster_thread_merger.cc.

                                                                           {
  merge_unmerge_callback_ = callback;
}

References callback.

Referenced by flutter::Rasterizer::Setup(), and flutter::Rasterizer::Teardown().

◆ UnMergeNowIfLastOne()

void fml::RasterThreadMerger::UnMergeNowIfLastOne ( )

Definition at line 77 of file raster_thread_merger.cc.

                                             {
  std::scoped_lock lock(mutex_);
 
  if (TaskQueuesAreSame()) {
    return;
  }
  if (!IsEnabledUnSafe()) {
    return;
  }
  bool success = shared_merger_->UnMergeNowIfLastOne(this);
  if (success && merge_unmerge_callback_ != nullptr) {
    merge_unmerge_callback_();
  }
}

References fml::SharedThreadMerger::UnMergeNowIfLastOne().

Referenced by flutter::Rasterizer::Teardown().

◆ WaitUntilMerged()

void fml::RasterThreadMerger::WaitUntilMerged ( )

Definition at line 150 of file raster_thread_merger.cc.

                                         {
  if (TaskQueuesAreSame()) {
    return;
  }
  FML_CHECK(IsOnPlatformThread());
  std::unique_lock<std::mutex> lock(mutex_);
  merged_condition_.wait(lock, [&] { return IsMergedUnSafe(); });
}

References FML_CHECK, and IsOnPlatformThread().

The documentation for this class was generated from the following files:

fml/raster_thread_merger.h
fml/raster_thread_merger.cc

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ CreateOrShareThreadMerger()

◆ DecrementLease()

◆ Disable()

◆ Enable()

◆ ExtendLeaseTo()

◆ GetSharedRasterThreadMerger()

◆ IsEnabled()

◆ IsMerged()

◆ IsOnPlatformThread()

◆ IsOnRasterizingThread()

◆ MergeWithLease()

◆ SetMergeUnmergeCallback()

◆ UnMergeNowIfLastOne()

◆ WaitUntilMerged()