mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
3078ba7036
This enables work ongoing by @derekxu16 to improve performance in flutter_tester when running multiple files from large test suites. Specifically, it: - Exposes a `Spawn` C symbol from flutter_tester that runs the current kernel in a new UI isolate with a different entrypoint and/or route name - Exposes two symbols from flutter_tester to allow a test harness to more efficiently load particular kernel files or to lookup an entrypoint from an imported source file. - Avoids re-loading the kernel file completely when spawning a new UI isolate Googlers can look at go/flutter-tester-isolates for some more context. If anyone wants I'm happy to create a public version of that doc.
210 lines
9.9 KiB
C++
210 lines
9.9 KiB
C++
// Copyright 2013 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef FLUTTER_SHELL_COMMON_RUN_CONFIGURATION_H_
|
|
#define FLUTTER_SHELL_COMMON_RUN_CONFIGURATION_H_
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include "flutter/assets/asset_manager.h"
|
|
#include "flutter/assets/asset_resolver.h"
|
|
#include "flutter/common/settings.h"
|
|
#include "flutter/fml/macros.h"
|
|
#include "flutter/fml/mapping.h"
|
|
#include "flutter/fml/unique_fd.h"
|
|
#include "flutter/runtime/isolate_configuration.h"
|
|
|
|
namespace flutter {
|
|
|
|
//------------------------------------------------------------------------------
|
|
/// @brief Specifies all the configuration required by the runtime library
|
|
/// to launch the root isolate. This object may be created on any
|
|
/// thread but must be given to the |Run| call of the |Engine| on
|
|
/// the UI thread. The configuration object is used to specify how
|
|
/// the root isolate finds its snapshots, assets, root library and
|
|
/// the "main" entrypoint.
|
|
///
|
|
class RunConfiguration {
|
|
public:
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Attempts to infer a run configuration from the settings
|
|
/// object. This tries to create a run configuration with sensible
|
|
/// defaults for the given Dart VM runtime mode. In JIT mode, this
|
|
/// will attempt to look for the VM and isolate snapshots in the
|
|
/// assets directory (must be specified in settings). In AOT mode,
|
|
/// it will attempt to look for known snapshot symbols in the
|
|
/// currently loaded process. The entrypoint defaults to
|
|
/// the "main" method in the root library.
|
|
///
|
|
/// @param[in] settings The settings object used to look for the various
|
|
/// snapshots and settings. This is usually initialized
|
|
/// from command line arguments.
|
|
/// @param[in] io_worker An optional IO worker. Resolving and reading the
|
|
/// various snapshots may be slow. Providing an IO
|
|
/// worker will ensure that realization of these
|
|
/// snapshots happens on a worker thread instead of the
|
|
/// calling thread. Note that the work done to realize
|
|
/// the snapshots may occur after this call returns. If
|
|
/// is the embedder's responsibility to make sure the
|
|
/// serial worker is kept alive for the lifetime of the
|
|
/// shell associated with the engine that this run
|
|
/// configuration is given to.
|
|
/// @param[in] launch_type Whether to launch the new isolate into an existing
|
|
/// group or a new one.
|
|
///
|
|
/// @return A run configuration. Depending on the completeness of the
|
|
/// settings, This object may potentially be invalid.
|
|
///
|
|
static RunConfiguration InferFromSettings(
|
|
const Settings& settings,
|
|
const fml::RefPtr<fml::TaskRunner>& io_worker = nullptr,
|
|
IsolateLaunchType launch_type = IsolateLaunchType::kNewGroup);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Creates a run configuration with only an isolate
|
|
/// configuration. There is no asset manager and default
|
|
/// entrypoint and root library are used ("main" in root library).
|
|
///
|
|
/// @param[in] configuration The configuration
|
|
///
|
|
explicit RunConfiguration(
|
|
std::unique_ptr<IsolateConfiguration> configuration);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Creates a run configuration with the specified isolate
|
|
/// configuration and asset manager. The default entrypoint and
|
|
/// root library are used ("main" in root library).
|
|
///
|
|
/// @param[in] configuration The configuration
|
|
/// @param[in] asset_manager The asset manager
|
|
///
|
|
RunConfiguration(std::unique_ptr<IsolateConfiguration> configuration,
|
|
std::shared_ptr<AssetManager> asset_manager);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Run configurations cannot be copied because it may not always
|
|
/// be possible to copy the underlying isolate snapshots. If
|
|
/// multiple run configurations share the same underlying
|
|
/// snapshots, creating a configuration from isolate snapshots
|
|
/// sharing the same underlying buffers is recommended.
|
|
///
|
|
/// @param config The run configuration to move.
|
|
///
|
|
RunConfiguration(RunConfiguration&& config);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief There are no threading restrictions on the destruction of the
|
|
/// run configuration.
|
|
///
|
|
~RunConfiguration();
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief A valid run configuration only guarantees that the engine
|
|
/// should be able to find the assets and the isolate snapshots
|
|
/// when it attempts to launch the root isolate. The validity of
|
|
/// the snapshot cannot be determined yet. That determination can
|
|
/// only be made when the configuration is used to run the root
|
|
/// isolate in the engine. However, the engine will always reject
|
|
/// an invalid run configuration.
|
|
///
|
|
/// @attention A valid run configuration does not mean that the root isolate
|
|
/// will always be launched. It only indicates that the various
|
|
/// snapshots are isolate snapshots and asset managers are present
|
|
/// and accounted for. The validity of the snapshots will only be
|
|
/// checked when the engine attempts to launch the root isolate.
|
|
///
|
|
/// @return Returns whether the snapshots and asset manager registrations
|
|
/// are valid.
|
|
///
|
|
bool IsValid() const;
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Asset managers maintain a list of resolvers that are checked
|
|
/// in order when attempting to locate an asset. This method adds
|
|
/// a resolver to the end of the list.
|
|
///
|
|
/// @param[in] resolver The asset resolver to add to the engine of the list
|
|
/// resolvers maintained by the asset manager.
|
|
///
|
|
/// @return Returns whether the resolver was successfully registered. The
|
|
/// resolver must be valid for its registration to be successful.
|
|
///
|
|
bool AddAssetResolver(std::unique_ptr<AssetResolver> resolver);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Updates the main application entrypoint. If this is not set,
|
|
/// the
|
|
/// "main" method is used as the entrypoint.
|
|
///
|
|
/// @param[in] entrypoint The entrypoint to use.
|
|
void SetEntrypoint(std::string entrypoint);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Specifies the main Dart entrypoint and the library to find
|
|
/// that entrypoint in. By default, this is the "main" method in
|
|
/// the root library. The root library may be specified by
|
|
/// entering the empty string as the second argument.
|
|
///
|
|
/// @see SetEntrypoint()
|
|
///
|
|
/// @param[in] entrypoint The entrypoint
|
|
/// @param[in] library The library
|
|
///
|
|
void SetEntrypointAndLibrary(std::string entrypoint, std::string library);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief Updates the main application entrypoint arguments.
|
|
///
|
|
/// @param[in] entrypoint_args The entrypoint arguments to use.
|
|
void SetEntrypointArgs(std::vector<std::string> entrypoint_args);
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @return The asset manager referencing all previously registered asset
|
|
/// resolvers.
|
|
///
|
|
std::shared_ptr<AssetManager> GetAssetManager() const;
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @return The main Dart entrypoint to be used for the root isolate.
|
|
///
|
|
const std::string& GetEntrypoint() const;
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @return The name of the library in which the main entrypoint resides.
|
|
/// If empty, the root library is used.
|
|
///
|
|
const std::string& GetEntrypointLibrary() const;
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @return Arguments passed as a List<String> to Dart's entrypoint
|
|
/// function.
|
|
///
|
|
const std::vector<std::string>& GetEntrypointArgs() const;
|
|
|
|
//----------------------------------------------------------------------------
|
|
/// @brief The engine uses this to take the isolate configuration from
|
|
/// the run configuration. The run configuration is no longer
|
|
/// valid after this call is made. The non-copyable nature of some
|
|
/// of the snapshots referenced in the isolate configuration is
|
|
/// why the run configuration as a whole is not copyable.
|
|
///
|
|
/// @return The run configuration if one is present.
|
|
///
|
|
std::unique_ptr<IsolateConfiguration> TakeIsolateConfiguration();
|
|
|
|
private:
|
|
std::unique_ptr<IsolateConfiguration> isolate_configuration_;
|
|
std::shared_ptr<AssetManager> asset_manager_;
|
|
std::string entrypoint_ = "main";
|
|
std::string entrypoint_library_ = "";
|
|
std::vector<std::string> entrypoint_args_;
|
|
|
|
FML_DISALLOW_COPY_AND_ASSIGN(RunConfiguration);
|
|
};
|
|
|
|
} // namespace flutter
|
|
|
|
#endif // FLUTTER_SHELL_COMMON_RUN_CONFIGURATION_H_
|