flutter::KernelListIsolateConfiguration Class Reference

Inheritance diagram for flutter::KernelListIsolateConfiguration:

Public Member Functions
	KernelListIsolateConfiguration (std::vector< std::future< std::unique_ptr< const fml::Mapping > > > kernel_pieces)
bool	DoPrepareIsolate (DartIsolate &isolate) override
bool	IsNullSafetyEnabled (const DartSnapshot &snapshot) override
void	ResolveKernelPiecesIfNecessary ()
Public Member Functions inherited from flutter::IsolateConfiguration
	IsolateConfiguration ()
	Create an isolate configuration. This has no threading restrictions.
virtual	~IsolateConfiguration ()
	Destroys an isolate configuration. This has no threading restrictions and may be collection of configurations may occur on any thread (and usually happens on an internal VM managed thread pool thread).
bool	PrepareIsolate (DartIsolate &isolate)
	When an isolate is created and sufficiently initialized to move it into the DartIsolate::Phase::LibrariesSetup phase, this method is invoked on the isolate to then move the isolate into the DartIsolate::Phase::Ready phase. Then isolate's main entrypoint is then invoked to move it into the DartIsolate::Phase::Running phase. This method will be called each time the root isolate is launched (which may be multiple times in cold-restart scenarios) as well as one each for any child isolates referenced by that isolate.

Additional Inherited Members
Static Public Member Functions inherited from flutter::IsolateConfiguration
static std::unique_ptr< IsolateConfiguration >	InferFromSettings (const Settings &settings, const std::shared_ptr< AssetManager > &asset_manager=nullptr, const fml::RefPtr< fml::TaskRunner > &io_worker=nullptr, IsolateLaunchType launch_type=IsolateLaunchType::kNewGroup)
	Attempts to infer the isolate configuration from the Settings object. If the VM is configured for AOT mode, snapshot resolution is attempted with predefined symbols present in the currently loaded process. In JIT mode, Dart kernel file resolution is attempted in the assets directory. If an IO worker is specified, snapshot resolution may be attempted on the serial worker task runner. The worker task runner thread must remain valid and running till after the shell associated with the engine used to launch the isolate for which this run configuration is used is collected.
static std::unique_ptr< IsolateConfiguration >	CreateForAppSnapshot ()
	Creates an AOT isolate configuration using snapshot symbols present in the currently loaded process. These symbols need to be given to the Dart VM on bootstrap and hence have already been resolved.
static std::unique_ptr< IsolateConfiguration >	CreateForKernelList (std::vector< std::future< std::unique_ptr< const fml::Mapping > > > kernel_pieces)
	Creates a JIT isolate configuration using a list of futures to snapshots defining the ready isolate state. In environments where snapshot resolution is extremely expensive, embedders attempt to resolve snapshots on worker thread(s) and return the future of the promise of snapshot resolution to this method. That way, snapshot resolution begins well before isolate launch is attempted by the engine.
static std::unique_ptr< IsolateConfiguration >	CreateForKernel (std::unique_ptr< const fml::Mapping > kernel)
	Creates a JIT isolate configuration using the specified snapshot. This is a convenience method for the CreateForKernelList method that takes a list of futures to Dart kernel snapshots.
static std::unique_ptr< IsolateConfiguration >	CreateForKernelList (std::vector< std::unique_ptr< const fml::Mapping > > kernel_pieces)
	Creates a JIT isolate configuration using the specified snapshots. This is a convenience method for the CreateForKernelList method that takes a list of futures to Dart kernel snapshots.

Detailed Description

Definition at line 72 of file isolate_configuration.cc.

Constructor & Destructor Documentation

KernelListIsolateConfiguration()

flutter::KernelListIsolateConfiguration::KernelListIsolateConfiguration ( std::vector< std::future< std::unique_ptr< const fml::Mapping > > >  kernel_pieces )

inlineexplicit

Definition at line 74 of file isolate_configuration.cc.

      : kernel_piece_futures_(std::move(kernel_pieces)) {
    if (kernel_piece_futures_.empty()) {
      FML_LOG(ERROR) << "Attempted to create kernel list configuration without "
                        "any kernel blobs.";
    }
  }

Member Function Documentation

DoPrepareIsolate()

bool flutter::KernelListIsolateConfiguration::DoPrepareIsolate ( DartIsolate &  isolate )

inlineoverridevirtual

Implements flutter::IsolateConfiguration.

Definition at line 85 of file isolate_configuration.cc.

                                                       {
    if (DartVM::IsRunningPrecompiledCode()) {
      return false;
    }
 
    ResolveKernelPiecesIfNecessary();
 
    if (resolved_kernel_pieces_.empty()) {
      FML_DLOG(ERROR) << "No kernel pieces provided to prepare this isolate.";
      return false;
    }
 
    for (size_t i = 0; i < resolved_kernel_pieces_.size(); i++) {
      if (!resolved_kernel_pieces_[i]) {
        FML_DLOG(ERROR) << "This kernel list isolate configuration was already "
                           "used to prepare an isolate.";
        return false;
      }
      const bool last_piece = i + 1 == resolved_kernel_pieces_.size();
      if (!isolate.PrepareForRunningFromKernel(
              std::move(resolved_kernel_pieces_[i]), /*child_isolate=*/false,
              last_piece)) {
        return false;
      }
    }
 
    return true;
  }

IsNullSafetyEnabled()

bool flutter::KernelListIsolateConfiguration::IsNullSafetyEnabled ( const DartSnapshot &  snapshot )

inlineoverridevirtual

Implements flutter::IsolateConfiguration.

Definition at line 115 of file isolate_configuration.cc.

                                                                  {
    ResolveKernelPiecesIfNecessary();
    const auto kernel = resolved_kernel_pieces_.empty()
                            ? nullptr
                            : resolved_kernel_pieces_.front().get();
    return snapshot.IsNullSafetyEnabled(kernel);
  }

ResolveKernelPiecesIfNecessary()

void flutter::KernelListIsolateConfiguration::ResolveKernelPiecesIfNecessary ( )

inline

Definition at line 127 of file isolate_configuration.cc.

                                        {
    if (resolved_kernel_pieces_.size() == kernel_piece_futures_.size()) {
      return;
    }
 
    resolved_kernel_pieces_.clear();
    for (auto& piece : kernel_piece_futures_) {
      // The get() call will xfer the unique pointer out and leave an empty
      // future in the original vector.
      resolved_kernel_pieces_.emplace_back(piece.get());
    }
  }

---

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

• runtime/isolate_configuration.cc