fml::RasterThreadMerger Class Reference

#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

This class is a client and proxy between the rasterizer and |SharedThreadMerger|. The multiple |RasterThreadMerger| instances with same owner_queue_id and same subsumed_queue_id share the same |SharedThreadMerger| instance. Whether they share the same inner instance is determined by |RasterThreadMerger::CreateOrShareThreadMerger| method.

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);
  }
}

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;
}

Disable()

void fml::RasterThreadMerger::Disable

(

)

Definition at line 128 of file raster_thread_merger.cc.

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

Enable()

void fml::RasterThreadMerger::Enable

(

)

Definition at line 123 of file raster_thread_merger.cc.

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

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);
}

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();
}

IsMerged()

bool fml::RasterThreadMerger::IsMerged

(

)

Definition at line 118 of file raster_thread_merger.cc.

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

IsOnPlatformThread()

bool fml::RasterThreadMerger::IsOnPlatformThread

(

)

const

Definition at line 92 of file raster_thread_merger.cc.

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

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();
  }
}

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();
}

SetMergeUnmergeCallback()

void fml::RasterThreadMerger::SetMergeUnmergeCallback

(

const fml::closure &

callback

)

Definition at line 30 of file raster_thread_merger.cc.

                                                                           {
  merge_unmerge_callback_ = callback;
}

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_();
  }
}

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(); });
}

---

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

• fml/raster_thread_merger.h
• fml/raster_thread_merger.cc