flutter_runner Namespace Reference

Namespaces
namespace	testing

Classes
class	AccessibilityBridge
struct	ActiveComponentV2
class	CompatTaskRunner
class	ComponentV2
class	Engine
class	ExternalViewEmbedder
class	FileInNamespaceBuffer
	A mapping to a buffer for a file that has been loaded into a namespace. More...
class	FlatlandConnection
class	FlutterRunnerProductConfiguration
class	FocusDelegate
class	IsolateConfigurator
struct	IxnHasher
class	Keyboard
class	Overflow
class	PlatformView
class	PointerDelegate
class	PointerInjectorDelegate
struct	ProgramMetadata
class	Runner
class	SoftwareSurface
class	SoftwareSurfaceProducer
class	Surface
class	SurfaceProducer
class	SurfaceProducerSurface
class	TextDelegate
struct	UniqueFDIONSTraits
class	VsyncWaiter
struct	VulkanImage
class	VulkanSurface
class	VulkanSurfacePool
class	VulkanSurfaceProducer

Typedefs
using	ViewCallback = std::function< void()>
using	ViewCreatedCallback = std::function< void(fuchsia::ui::composition::ContentId, fuchsia::ui::composition::ChildViewWatcherHandle child_view_watcher)>
using	ViewIdCallback = std::function< void(fuchsia::ui::composition::ContentId)>
using	on_frame_presented_event = std::function< void(fuchsia::scenic::scheduling::FramePresentedInfo)>
using	OnEnableWireframeCallback = fit::function< void(bool)>
using	OnUpdateViewCallback = fit::function< void(int64_t, SkRect, bool, bool)>
using	OnCreateSurfaceCallback = fit::function< std::unique_ptr< flutter::Surface >()>
using	OnSemanticsNodeUpdateCallback = fit::function< void(flutter::SemanticsNodeUpdates, float)>
using	OnRequestAnnounceCallback = fit::function< void(std::string)>
using	OnCreateViewCallback = fit::function< void(int64_t, ViewCallback, ViewCreatedCallback, bool, bool)>
using	OnDestroyViewCallback = fit::function< void(int64_t, ViewIdCallback)>
using	OnShaderWarmupCallback = std::function< void(const std::vector< std::string > &, std::function< void(uint32_t)>, uint64_t, uint64_t)>
using	fup_EventPhase = fuchsia::ui::pointer::EventPhase
using	fup_MouseDeviceInfo = fuchsia::ui::pointer::MouseDeviceInfo
using	fup_MouseEvent = fuchsia::ui::pointer::MouseEvent
using	fup_TouchEvent = fuchsia::ui::pointer::TouchEvent
using	fup_TouchIxnStatus = fuchsia::ui::pointer::TouchInteractionStatus
using	fup_TouchResponse = fuchsia::ui::pointer::TouchResponse
using	fup_TouchResponseType = fuchsia::ui::pointer::TouchResponseType
using	fup_ViewParameters = fuchsia::ui::pointer::ViewParameters
using	fup_Config = fuchsia::ui::pointerinjector::Config
using	fup_Context = fuchsia::ui::pointerinjector::Context
using	fup_Data = fuchsia::ui::pointerinjector::Data
using	fup_DeviceType = fuchsia::ui::pointerinjector::DeviceType
using	fup_DispatchPolicy = fuchsia::ui::pointerinjector::DispatchPolicy
using	fup_Event = fuchsia::ui::pointerinjector::Event
using	fup_PointerSample = fuchsia::ui::pointerinjector::PointerSample
using	fup_Target = fuchsia::ui::pointerinjector::Target
using	fup_Viewport = fuchsia::ui::pointerinjector::Viewport
using	fuv_ViewRef = fuchsia::ui::views::ViewRef
using	ReleaseImageCallback = std::function< void()>
using	UniqueFDIONS = fml::UniqueObject< fdio_ns_t *, UniqueFDIONSTraits >
using	FireCallbackCallback = std::function< void(fml::TimePoint, fml::TimePoint)>
using	AwaitVsyncCallback = std::function< void(FireCallbackCallback)>
using	AwaitVsyncForSecondaryCallbackCallback = std::function< void(FireCallbackCallback)>

Functions
static uint32_t	FlutterIdToFuchsiaId (int32_t flutter_node_id)
static void	PrintNodeSizeError (uint32_t node_id)
std::unique_ptr< fml::Mapping >	LoadFile (int namespace_fd, const char *path, bool executable)
std::unique_ptr< fml::FileMapping >	MakeFileMapping (const char *path, bool executable)
static void	Enqueue (zx::event fence, std::vector< zx::event > *fences, std::shared_ptr< Overflow > *overflow)
fml::MallocMapping	MakeLocalizationPlatformMessageData (const Profile &intl_profile)
fml::MallocMapping	MakeLocalizationPlatformMessageData (const fuchsia::intl::Profile &intl_profile)
static flutter::PointerData::Change	GetChangeFromPointerEventPhase (fuchsia::ui::input::PointerEventPhase phase)
static flutter::PointerData::DeviceKind	GetKindFromPointerType (fuchsia::ui::input::PointerEventType type)
static trace_flow_id_t	PointerTraceHACK (float fa, float fb)
static void	SetProcessName ()
static void	SetThreadName (const std::string &thread_name)
static void	RegisterProfilerSymbols (const char *symbols_path, const char *dso_name)
	TEST (RunnerTZDataTest, LoadsWithoutTZDataPresent)
	TEST (RunnerTZDataTest, LoadsWithTZDataPresent)
fml::RefPtr< fml::TaskRunner >	CreateFMLTaskRunner (async_dispatcher_t *dispatcher)
static fuchsia::ui::input::InputMethodAction	IntoInputMethodAction (const std::string action_string)
static const std::string	IntoTextInputAction (fuchsia::ui::input::InputMethodAction action)
template<class T >
void	SetInterfaceErrorHandler (fidl::InterfacePtr< T > &interface, std::string name)
template<class T >
void	SetInterfaceErrorHandler (fidl::Binding< T > &binding, std::string name)
UniqueFDIONS	UniqueFDIONSCreate ()
	TEST (VSyncWaiterFuchsia, FrameScheduledForStartTime)
static std::string	GetCurrentProcessName ()
static zx_koid_t	GetCurrentProcessId ()

Variables
static constexpr size_t	kMaxFences
static constexpr fml::TimeDelta	kInitialFlatlandVsyncOffset
static constexpr char	kFlutterPlatformChannel [] = "flutter/platform"
static constexpr char	kAccessibilityChannel [] = "flutter/accessibility"
static constexpr char	kFlutterPlatformViewsChannel [] = "flutter/platform_views"
static constexpr char	kFuchsiaShaderWarmupChannel [] = "fuchsia/shader_warmup"
static constexpr char	kFuchsiaInputTestChannel [] = "fuchsia/input_test"
static constexpr char	kFuchsiaChildViewChannel [] = "fuchsia/child_view"
static constexpr int64_t	kFlutterImplicitViewId = 0ll
const auto	fup_MAX_INJECT = fuchsia::ui::pointerinjector::MAX_INJECT
static constexpr char	kInputActionKey [] = "inputAction"
static constexpr char	kTextInputActionDone [] = "TextInputAction.done"
static constexpr char	kTextInputActionNewline [] = "TextInputAction.newline"
static constexpr char	kTextInputActionGo [] = "TextInputAction.go"
static constexpr char	kTextInputActionNext [] = "TextInputAction.next"
static constexpr char	kTextInputActionPrevious [] = "TextInputAction.previous"
static constexpr char	kTextInputActionNone [] = "TextInputAction.none"
static constexpr char	kTextInputActionSearch [] = "TextInputAction.search"
static constexpr char	kTextInputActionSend [] = "TextInputAction.send"
static constexpr char	kTextInputActionUnspecified []
constexpr char	kTextInputChannel [] = "flutter/textinput"
	The channel name used for text editing platofrm messages. More...
constexpr char	kKeyEventChannel [] = "flutter/keyevent"
	The channel name used for key event platform messages. More...

Detailed Description

Text editing functionality delegated from |PlatformView|. See |TextDelegate| for details.

Typedef Documentation

AwaitVsyncCallback

using flutter_runner::AwaitVsyncCallback = typedef std::function<void(FireCallbackCallback)>

Definition at line 22 of file vsync_waiter.h.

AwaitVsyncForSecondaryCallbackCallback

using flutter_runner::AwaitVsyncForSecondaryCallbackCallback = typedef std::function<void(FireCallbackCallback)>

Definition at line 24 of file vsync_waiter.h.

FireCallbackCallback

using flutter_runner::FireCallbackCallback = typedef std::function<void(fml::TimePoint, fml::TimePoint)>

Definition at line 19 of file vsync_waiter.h.

fup_Config

using flutter_runner::fup_Config = typedef fuchsia::ui::pointerinjector::Config

Definition at line 10 of file pointer_injector_delegate.cc.

fup_Context

using flutter_runner::fup_Context = typedef fuchsia::ui::pointerinjector::Context

Definition at line 11 of file pointer_injector_delegate.cc.

fup_Data

using flutter_runner::fup_Data = typedef fuchsia::ui::pointerinjector::Data

Definition at line 12 of file pointer_injector_delegate.cc.

fup_DeviceType

using flutter_runner::fup_DeviceType = typedef fuchsia::ui::pointerinjector::DeviceType

Definition at line 13 of file pointer_injector_delegate.cc.

fup_DispatchPolicy

using flutter_runner::fup_DispatchPolicy = typedef fuchsia::ui::pointerinjector::DispatchPolicy

Definition at line 14 of file pointer_injector_delegate.cc.

fup_Event

using flutter_runner::fup_Event = typedef fuchsia::ui::pointerinjector::Event

Definition at line 15 of file pointer_injector_delegate.cc.

fup_EventPhase

typedef fuchsia::ui::pointerinjector::EventPhase flutter_runner::fup_EventPhase

Definition at line 29 of file pointer_delegate.cc.

fup_MouseDeviceInfo

using flutter_runner::fup_MouseDeviceInfo = typedef fuchsia::ui::pointer::MouseDeviceInfo

Definition at line 30 of file pointer_delegate.cc.

fup_MouseEvent

using flutter_runner::fup_MouseEvent = typedef fuchsia::ui::pointer::MouseEvent

Definition at line 31 of file pointer_delegate.cc.

fup_PointerSample

using flutter_runner::fup_PointerSample = typedef fuchsia::ui::pointerinjector::PointerSample

Definition at line 17 of file pointer_injector_delegate.cc.

fup_Target

using flutter_runner::fup_Target = typedef fuchsia::ui::pointerinjector::Target

Definition at line 18 of file pointer_injector_delegate.cc.

fup_TouchEvent

using flutter_runner::fup_TouchEvent = typedef fuchsia::ui::pointer::TouchEvent

Definition at line 32 of file pointer_delegate.cc.

fup_TouchIxnStatus

using flutter_runner::fup_TouchIxnStatus = typedef fuchsia::ui::pointer::TouchInteractionStatus

Definition at line 33 of file pointer_delegate.cc.

fup_TouchResponse

using flutter_runner::fup_TouchResponse = typedef fuchsia::ui::pointer::TouchResponse

Definition at line 34 of file pointer_delegate.cc.

fup_TouchResponseType

using flutter_runner::fup_TouchResponseType = typedef fuchsia::ui::pointer::TouchResponseType

Definition at line 35 of file pointer_delegate.cc.

fup_ViewParameters

using flutter_runner::fup_ViewParameters = typedef fuchsia::ui::pointer::ViewParameters

Definition at line 36 of file pointer_delegate.cc.

fup_Viewport

using flutter_runner::fup_Viewport = typedef fuchsia::ui::pointerinjector::Viewport

Definition at line 19 of file pointer_injector_delegate.cc.

fuv_ViewRef

using flutter_runner::fuv_ViewRef = typedef fuchsia::ui::views::ViewRef

Definition at line 20 of file pointer_injector_delegate.cc.

on_frame_presented_event

using flutter_runner::on_frame_presented_event = typedef std::function<void(fuchsia::scenic::scheduling::FramePresentedInfo)>

Definition at line 41 of file flatland_connection.h.

OnCreateSurfaceCallback

using flutter_runner::OnCreateSurfaceCallback = typedef fit::function<std::unique_ptr<flutter::Surface>()>

Definition at line 45 of file platform_view.h.

OnCreateViewCallback

using flutter_runner::OnCreateViewCallback = typedef fit::function<void(int64_t, ViewCallback, ViewCreatedCallback, bool, bool)>

Definition at line 50 of file platform_view.h.

OnDestroyViewCallback

using flutter_runner::OnDestroyViewCallback = typedef fit::function<void(int64_t, ViewIdCallback)>

Definition at line 52 of file platform_view.h.

OnEnableWireframeCallback

using flutter_runner::OnEnableWireframeCallback = typedef fit::function<void(bool)>

Definition at line 42 of file platform_view.h.

OnRequestAnnounceCallback

using flutter_runner::OnRequestAnnounceCallback = typedef fit::function<void(std::string)>

Definition at line 49 of file platform_view.h.

OnSemanticsNodeUpdateCallback

using flutter_runner::OnSemanticsNodeUpdateCallback = typedef fit::function<void(flutter::SemanticsNodeUpdates, float)>

Definition at line 47 of file platform_view.h.

OnShaderWarmupCallback

using flutter_runner::OnShaderWarmupCallback = typedef std::function<void(const std::vector<std::string>&, std::function<void(uint32_t)>, uint64_t, uint64_t)>

Definition at line 57 of file platform_view.h.

OnUpdateViewCallback

using flutter_runner::OnUpdateViewCallback = typedef fit::function<void(int64_t, SkRect, bool, bool)>

Definition at line 44 of file platform_view.h.

ReleaseImageCallback

using flutter_runner::ReleaseImageCallback = typedef std::function<void()>

Definition at line 21 of file surface_producer.h.

UniqueFDIONS

using flutter_runner::UniqueFDIONS = typedef fml::UniqueObject<fdio_ns_t*, UniqueFDIONSTraits>

Definition at line 25 of file unique_fdio_ns.h.

ViewCallback

typedef std::function< void()> flutter_runner::ViewCallback

Definition at line 34 of file external_view_embedder.h.

ViewCreatedCallback

using flutter_runner::ViewCreatedCallback = typedef std::function<void( fuchsia::ui::composition::ContentId, fuchsia::ui::composition::ChildViewWatcherHandle child_view_watcher)>

Definition at line 35 of file external_view_embedder.h.

ViewIdCallback

using flutter_runner::ViewIdCallback = typedef std::function<void(fuchsia::ui::composition::ContentId)>

Definition at line 38 of file external_view_embedder.h.

Function Documentation

CreateFMLTaskRunner()

fml::RefPtr< fml::TaskRunner > flutter_runner::CreateFMLTaskRunner

(

async_dispatcher_t *

dispatcher

)

Definition at line 51 of file task_runner_adapter.cc.

                                    {
  return fml::MakeRefCounted<CompatTaskRunner>(dispatcher);
}

Enqueue()

static void flutter_runner::Enqueue ( zx::event  fence, std::vector< zx::event > *  fences, std::shared_ptr< Overflow > *  overflow  )

static

Definition at line 355 of file flatland_connection.cc.

                                                       {
  constexpr size_t kMaxFences =
      fuchsia::ui::composition::MAX_ACQUIRE_RELEASE_FENCE_COUNT;
 
  // Number of all previously added fences, plus this one.
  const auto num_all_fences =
      fences->size() + 1 +
      ((*overflow == nullptr) ? 0 : (*overflow)->fences_.size());
 
  // If more than max number of fences come in, schedule any further fences into
  // an overflow. The overflow fences are scheduled for processing here, but are
  // processed in DoPresent().
  if (num_all_fences <= kMaxFences) {
    fences->push_back(std::move(fence));
  } else if (num_all_fences == kMaxFences + 1) {
    // The ownership of the overflow will be handed over to the signaling
    // closure on DoPresent call. So we always expect that we enter here with
    // overflow not set.
    FML_CHECK((*overflow) == nullptr) << "overflow is still active";
    *overflow = std::make_shared<Overflow>();
 
    // Set up the overflow fences. Creates an overflow handle, places it
    // into `fences` instead of the previous fence, and puts the prior fence
    // and this one into overflow.
    zx::event overflow_handle = std::move(fences->back());
    fences->pop_back();
 
    zx::event overflow_fence;
    zx_status_t status = zx::event::create(0, &overflow_fence);
    FML_CHECK(status == ZX_OK) << "status: " << zx_status_get_string(status);
 
    // Every DoPresent should invalidate this handle.  Holler if not.
    FML_CHECK(!(*overflow)->event_.is_valid()) << "overflow valid";
    status =
        overflow_fence.duplicate(ZX_RIGHT_SAME_RIGHTS, &(*overflow)->event_);
    FML_CHECK(status == ZX_OK) << "status: " << zx_status_get_string(status);
    fences->push_back(std::move(overflow_fence));
 
    // Prepare for wait_many call.
    (*overflow)->fences_.push_back(std::move(overflow_handle));
    (*overflow)->fences_.push_back(std::move(fence));
 
    FML_LOG(INFO) << "Enqueue using fence overflow, expect a performance hit.";
  } else {
    FML_CHECK((*overflow) != nullptr);
    // Just add to the overflow fences.
    (*overflow)->fences_.push_back(std::move(fence));
  }
}

FlutterIdToFuchsiaId()

static uint32_t flutter_runner::FlutterIdToFuchsiaId ( int32_t  flutter_node_id )

static

Definition at line 497 of file accessibility_bridge.cc.

                                                              {
  FML_DCHECK(flutter_node_id >= 0)
      << "Unexpectedly received a negative semantics node ID.";
  return static_cast<uint32_t>(flutter_node_id);
}

GetChangeFromPointerEventPhase()

static flutter::PointerData::Change flutter_runner::GetChangeFromPointerEventPhase ( fuchsia::ui::input::PointerEventPhase  phase )

static

Definition at line 256 of file platform_view.cc.

                                           {
  switch (phase) {
    case fuchsia::ui::input::PointerEventPhase::ADD:
      return flutter::PointerData::Change::kAdd;
    case fuchsia::ui::input::PointerEventPhase::HOVER:
      return flutter::PointerData::Change::kHover;
    case fuchsia::ui::input::PointerEventPhase::DOWN:
      return flutter::PointerData::Change::kDown;
    case fuchsia::ui::input::PointerEventPhase::MOVE:
      return flutter::PointerData::Change::kMove;
    case fuchsia::ui::input::PointerEventPhase::UP:
      return flutter::PointerData::Change::kUp;
    case fuchsia::ui::input::PointerEventPhase::REMOVE:
      return flutter::PointerData::Change::kRemove;
    case fuchsia::ui::input::PointerEventPhase::CANCEL:
      return flutter::PointerData::Change::kCancel;
    default:
      return flutter::PointerData::Change::kCancel;
  }
}

GetCurrentProcessId()

static zx_koid_t flutter_runner::GetCurrentProcessId ( )

static

Definition at line 25 of file vulkan_surface_pool.cc.

                                       {
  zx_info_handle_basic_t info;
  zx_status_t status = zx::process::self()->get_info(
      ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
  return status == ZX_OK ? info.koid : ZX_KOID_INVALID;
}

GetCurrentProcessName()

static std::string flutter_runner::GetCurrentProcessName ( )

static

Definition at line 18 of file vulkan_surface_pool.cc.

                                         {
  char name[ZX_MAX_NAME_LEN];
  zx_status_t status =
      zx::process::self()->get_property(ZX_PROP_NAME, name, sizeof(name));
  return status == ZX_OK ? std::string(name) : std::string();
}

GetKindFromPointerType()

static flutter::PointerData::DeviceKind flutter_runner::GetKindFromPointerType ( fuchsia::ui::input::PointerEventType  type )

static

Definition at line 278 of file platform_view.cc.

                                         {
  switch (type) {
    case fuchsia::ui::input::PointerEventType::TOUCH:
      return flutter::PointerData::DeviceKind::kTouch;
    case fuchsia::ui::input::PointerEventType::MOUSE:
      return flutter::PointerData::DeviceKind::kMouse;
    default:
      return flutter::PointerData::DeviceKind::kTouch;
  }
}

IntoInputMethodAction()

static fuchsia::ui::input::InputMethodAction flutter_runner::IntoInputMethodAction ( const std::string  action_string )

static

Definition at line 41 of file text_delegate.cc.

                                   {
  if (action_string == kTextInputActionNewline) {
    return fuchsia::ui::input::InputMethodAction::NEWLINE;
  } else if (action_string == kTextInputActionDone) {
    return fuchsia::ui::input::InputMethodAction::DONE;
  } else if (action_string == kTextInputActionGo) {
    return fuchsia::ui::input::InputMethodAction::GO;
  } else if (action_string == kTextInputActionNext) {
    return fuchsia::ui::input::InputMethodAction::NEXT;
  } else if (action_string == kTextInputActionPrevious) {
    return fuchsia::ui::input::InputMethodAction::PREVIOUS;
  } else if (action_string == kTextInputActionNone) {
    return fuchsia::ui::input::InputMethodAction::NONE;
  } else if (action_string == kTextInputActionSearch) {
    return fuchsia::ui::input::InputMethodAction::SEARCH;
  } else if (action_string == kTextInputActionSend) {
    return fuchsia::ui::input::InputMethodAction::SEND;
  } else if (action_string == kTextInputActionUnspecified) {
    return fuchsia::ui::input::InputMethodAction::UNSPECIFIED;
  }
  // If this message comes along it means we should really add the missing 'if'
  // above.
  FML_VLOG(1) << "unexpected action_string: " << action_string;
  // Substituting DONE for an unexpected action string will probably be OK.
  return fuchsia::ui::input::InputMethodAction::DONE;
}

IntoTextInputAction()

static const std::string flutter_runner::IntoTextInputAction ( fuchsia::ui::input::InputMethodAction  action )

static

Definition at line 70 of file text_delegate.cc.

                                            {
  if (action == fuchsia::ui::input::InputMethodAction::NEWLINE) {
    return kTextInputActionNewline;
  } else if (action == fuchsia::ui::input::InputMethodAction::DONE) {
    return kTextInputActionDone;
  } else if (action == fuchsia::ui::input::InputMethodAction::GO) {
    return kTextInputActionGo;
  } else if (action == fuchsia::ui::input::InputMethodAction::NEXT) {
    return kTextInputActionNext;
  } else if (action == fuchsia::ui::input::InputMethodAction::PREVIOUS) {
    return kTextInputActionPrevious;
  } else if (action == fuchsia::ui::input::InputMethodAction::NONE) {
    return kTextInputActionNone;
  } else if (action == fuchsia::ui::input::InputMethodAction::SEARCH) {
    return kTextInputActionSearch;
  } else if (action == fuchsia::ui::input::InputMethodAction::SEND) {
    return kTextInputActionSend;
  } else if (action == fuchsia::ui::input::InputMethodAction::UNSPECIFIED) {
    return kTextInputActionUnspecified;
  }
  // If this message comes along it means we should really add the missing 'if'
  // above.
  FML_VLOG(1) << "unexpected action: " << static_cast<uint32_t>(action);
  // Substituting "done" for an unexpected text input action will probably
  // be OK.
  return kTextInputActionDone;
}

LoadFile()

std::unique_ptr< fml::Mapping > flutter_runner::LoadFile	(	int	namespace_fd,
		const char *	path,
		bool	executable
	)

Loads a file from |file_path| into the namespace |namespace_fd|, returning the mapping for that file.

The file will be loaded with the readable permission. If |executable| is true, the file will be also be loaded with the executable permission.

Definition at line 67 of file file_in_namespace_buffer.cc.

                                                        {
  FML_TRACE_EVENT("flutter", "LoadFile", "path", path);
  return std::make_unique<FileInNamespaceBuffer>(namespace_fd, path,
                                                 executable);
}

MakeFileMapping()

std::unique_ptr< fml::FileMapping > flutter_runner::MakeFileMapping	(	const char *	path,
		bool	executable
	)

Opens the file at |path| and creates a file mapping for the file.

The file will be opened with the readable permission. If |executable| is true, the file will also be opened with the executable permission.

Definition at line 75 of file file_in_namespace_buffer.cc.

                                                                   {
  auto flags = fuchsia::io::OpenFlags::RIGHT_READABLE;
  if (executable) {
    flags |= fuchsia::io::OpenFlags::RIGHT_EXECUTABLE;
  }
 
  // The returned file descriptor is compatible with standard posix operations
  // such as close, mmap, etc. We only need to treat open/open_at specially.
  int fd;
  const zx_status_t status =
      fdio_open_fd(path, static_cast<uint32_t>(flags), &fd);
  if (status != ZX_OK) {
    return nullptr;
  }
 
  using Protection = fml::FileMapping::Protection;
 
  std::initializer_list<Protection> protection_execute = {Protection::kRead,
                                                          Protection::kExecute};
  std::initializer_list<Protection> protection_read = {Protection::kRead};
  auto mapping = std::make_unique<fml::FileMapping>(
      fml::UniqueFD{fd}, executable ? protection_execute : protection_read);
 
  if (!mapping->IsValid()) {
    return nullptr;
  }
  return mapping;
}

MakeLocalizationPlatformMessageData() [1/2]

fml::MallocMapping flutter_runner::MakeLocalizationPlatformMessageData

(

const fuchsia::intl::Profile &

intl_profile

)

MakeLocalizationPlatformMessageData() [2/2]

fml::MallocMapping flutter_runner::MakeLocalizationPlatformMessageData

(

const Profile &

intl_profile

)

Definition at line 29 of file fuchsia_intl.cc.

                                 {
  rapidjson::Document document;
  auto& allocator = document.GetAllocator();
  document.SetObject();
  document.AddMember("method", "setLocale", allocator);
  rapidjson::Value args(rapidjson::kArrayType);
 
  for (const auto& locale_id : intl_profile.locales()) {
    UErrorCode error_code = U_ZERO_ERROR;
    icu::Locale locale = icu::Locale::forLanguageTag(locale_id.id, error_code);
    if (U_FAILURE(error_code)) {
      FML_LOG(ERROR) << "Error parsing locale ID \"" << locale_id.id << "\"";
      continue;
    }
    args.PushBack(rapidjson::Value().SetString(locale.getLanguage(), allocator),
                  allocator);
 
    auto country = locale.getCountry() != nullptr ? locale.getCountry() : "";
    args.PushBack(rapidjson::Value().SetString(country, allocator), allocator);
 
    auto script = locale.getScript() != nullptr ? locale.getScript() : "";
    args.PushBack(rapidjson::Value().SetString(script, allocator), allocator);
 
    std::string variant =
        locale.getVariant() != nullptr ? locale.getVariant() : "";
    // ICU4C capitalizes the variant for backward compatibility, even though
    // the preferred form is lowercase.  So we lowercase here.
    std::transform(begin(variant), end(variant), begin(variant),
                   [](unsigned char c) { return std::tolower(c); });
    args.PushBack(rapidjson::Value().SetString(variant, allocator), allocator);
  }
 
  document.AddMember("args", args, allocator);
 
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
  auto data = reinterpret_cast<const uint8_t*>(buffer.GetString());
  return fml::MallocMapping::Copy(data, buffer.GetSize());
}

PointerTraceHACK()

static trace_flow_id_t flutter_runner::PointerTraceHACK ( float  fa, float  fb  )

static

Definition at line 292 of file platform_view.cc.

                                                            {
  uint32_t ia, ib;
  memcpy(&ia, &fa, sizeof(uint32_t));
  memcpy(&ib, &fb, sizeof(uint32_t));
  return (((uint64_t)ia) << 32) | ib;
}

PrintNodeSizeError()

static void flutter_runner::PrintNodeSizeError ( uint32_t  node_id )

static

Definition at line 520 of file accessibility_bridge.cc.

                                                 {
  FML_LOG(ERROR) << "Semantics node with ID " << node_id
                 << " exceeded the maximum FIDL message size and may not "
                    "be delivered to the accessibility manager service.";
}

RegisterProfilerSymbols()

static void flutter_runner::RegisterProfilerSymbols ( const char *  symbols_path, const char *  dso_name  )

static

Definition at line 142 of file runner.cc.

                                                          {
  std::string* symbols = new std::string();
  if (dart_utils::ReadFileToString(symbols_path, symbols)) {
    Dart_AddSymbols(dso_name, symbols->data(), symbols->size());
  } else {
    FML_LOG(ERROR) << "Failed to load " << symbols_path;
  }
}

SetInterfaceErrorHandler() [1/2]

template<class T >

void flutter_runner::SetInterfaceErrorHandler	(	fidl::Binding< T > &	binding,
		std::string	name
	)

Definition at line 109 of file text_delegate.cc.

                                                                       {
  binding.set_error_handler([name](zx_status_t status) {
    FML_LOG(ERROR) << "Binding error on: " << name << ", status: " << status;
  });
}

SetInterfaceErrorHandler() [2/2]

template<class T >

void flutter_runner::SetInterfaceErrorHandler	(	fidl::InterfacePtr< T > &	interface,
		std::string	name
	)

Definition at line 102 of file text_delegate.cc.

                                              {
  interface.set_error_handler([name](zx_status_t status) {
    FML_LOG(ERROR) << "Interface error on: " << name << ", status: " << status;
  });
}

SetProcessName()

static void flutter_runner::SetProcessName ( )

static

Definition at line 119 of file runner.cc.

                             {
  std::stringstream stream;
#if defined(DART_PRODUCT)
  stream << "io.flutter.product_runner.";
#else
  stream << "io.flutter.runner.";
#endif
  if (flutter::DartVM::IsRunningPrecompiledCode()) {
    stream << "aot";
  } else {
    stream << "jit";
  }
  const auto name = stream.str();
  zx::process::self()->set_property(ZX_PROP_NAME, name.c_str(), name.size());
}

SetThreadName()

static void flutter_runner::SetThreadName ( const std::string &  thread_name )

static

Definition at line 135 of file runner.cc.

                                                        {
  zx::thread::self()->set_property(ZX_PROP_NAME, thread_name.c_str(),
                                   thread_name.size());
}

TEST() [1/3]

flutter_runner::TEST	(	RunnerTZDataTest	,
		LoadsWithoutTZDataPresent
	)

Definition at line 15 of file runner_tzdata_missing_unittest.cc.

                                                  {
  bool success = Runner::SetupICUInternal();
  ASSERT_TRUE(success) << "failed to load set up ICU data";
}

TEST() [2/3]

flutter_runner::TEST	(	RunnerTZDataTest	,
		LoadsWithTZDataPresent
	)

Definition at line 14 of file runner_tzdata_unittest.cc.

                                               {
  // TODO(fxbug.dev/69570): Move to cml file if env_vars gains supported for the
  // gtest_runner.
  setenv("ICU_TIMEZONE_FILES_DIR", "/pkg/data/tzdata", true);
 
  UErrorCode err = U_ZERO_ERROR;
  const auto version_before = std::string(icu::TimeZone::getTZDataVersion(err));
  ASSERT_EQ(U_ZERO_ERROR, err) << "unicode error: " << u_errorName(err);
 
  // This loads the tzdata. In Fuchsia, we force the data from this package
  // to be version 2019a, so that we can test the resource load.
  bool success = Runner::SetupICUInternal();
  ASSERT_TRUE(success) << "failed to load timezone data";
 
  const auto version_after = std::string(icu::TimeZone::getTZDataVersion(err));
  ASSERT_EQ(U_ZERO_ERROR, err) << "unicode error: " << u_errorName(err);
 
  EXPECT_EQ("2019a", version_after);
}

TEST() [3/3]

flutter_runner::TEST	(	VSyncWaiterFuchsia	,
		FrameScheduledForStartTime
	)

Definition at line 20 of file vsync_waiter_unittest.cc.

                                                     {
  using flutter::ThreadHost;
  std::string prefix = "vsync_waiter_test";
 
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto platform_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
 
  ThreadHost thread_host =
      ThreadHost(prefix, flutter::ThreadHost::Type::kRaster |
                             flutter::ThreadHost::Type::kUi |
                             flutter::ThreadHost::Type::kIo);
  const flutter::TaskRunners task_runners(
      prefix,                                      // Dart thread labels
      platform_task_runner,                        // platform
      thread_host.raster_thread->GetTaskRunner(),  // raster
      thread_host.ui_thread->GetTaskRunner(),      // ui
      thread_host.io_thread->GetTaskRunner()       // io
  );
 
  // await vsync will invoke the callback right away, but vsync waiter will post
  // the task for frame_start time.
  VsyncWaiter vsync_waiter(
      [](FireCallbackCallback callback) {
        const auto now = fml::TimePoint::Now();
        const auto frame_start = now + fml::TimeDelta::FromMilliseconds(20);
        const auto frame_end = now + fml::TimeDelta::FromMilliseconds(36);
        callback(frame_start, frame_end);
      },
      /*secondary callback*/ nullptr, task_runners);
 
  fml::AutoResetWaitableEvent latch;
  task_runners.GetUITaskRunner()->PostTask([&]() {
    vsync_waiter.AsyncWaitForVsync(
        [&](std::unique_ptr<flutter::FrameTimingsRecorder> recorder) {
          const auto now = fml::TimePoint::Now();
          EXPECT_GT(now, recorder->GetVsyncStartTime());
          latch.Signal();
        });
  });
 
  latch.Wait();
}

UniqueFDIONSCreate()

UniqueFDIONS flutter_runner::UniqueFDIONSCreate ( )

inline

Definition at line 27 of file unique_fdio_ns.h.

                                         {
  fdio_ns_t* ns = nullptr;
  if (fdio_ns_create(&ns) == ZX_OK) {
    return UniqueFDIONS{ns};
  }
  return UniqueFDIONS{nullptr};
}

Variable Documentation

fup_MAX_INJECT

const auto flutter_runner::fup_MAX_INJECT = fuchsia::ui::pointerinjector::MAX_INJECT

Definition at line 21 of file pointer_injector_delegate.cc.

kAccessibilityChannel

constexpr char flutter_runner::kAccessibilityChannel[] = "flutter/accessibility"

staticconstexpr

Definition at line 52 of file platform_view.cc.

kFlutterImplicitViewId

constexpr int64_t flutter_runner::kFlutterImplicitViewId = 0ll

staticconstexpr

Definition at line 57 of file platform_view.cc.

kFlutterPlatformChannel

constexpr char flutter_runner::kFlutterPlatformChannel[] = "flutter/platform"

staticconstexpr

Definition at line 51 of file platform_view.cc.

kFlutterPlatformViewsChannel

constexpr char flutter_runner::kFlutterPlatformViewsChannel[] = "flutter/platform_views"

staticconstexpr

Definition at line 53 of file platform_view.cc.

kFuchsiaChildViewChannel

constexpr char flutter_runner::kFuchsiaChildViewChannel[] = "fuchsia/child_view"

staticconstexpr

Definition at line 56 of file platform_view.cc.

kFuchsiaInputTestChannel

constexpr char flutter_runner::kFuchsiaInputTestChannel[] = "fuchsia/input_test"

staticconstexpr

Definition at line 55 of file platform_view.cc.

kFuchsiaShaderWarmupChannel

constexpr char flutter_runner::kFuchsiaShaderWarmupChannel[] = "fuchsia/shader_warmup"

staticconstexpr

Definition at line 54 of file platform_view.cc.

kInitialFlatlandVsyncOffset

constexpr fml::TimeDelta flutter_runner::kInitialFlatlandVsyncOffset

staticconstexpr

Initial value:

=
    fml::TimeDelta::FromMilliseconds(10)

Definition at line 46 of file flatland_connection.h.

kInputActionKey

constexpr char flutter_runner::kInputActionKey[] = "inputAction"

staticconstexpr

Definition at line 25 of file text_delegate.cc.

kKeyEventChannel

constexpr char flutter_runner::kKeyEventChannel[] = "flutter/keyevent"

constexpr

The channel name used for key event platform messages.

Definition at line 30 of file text_delegate.h.

kMaxFences

constexpr size_t flutter_runner::kMaxFences

staticconstexpr

Initial value:

=
    fuchsia::ui::composition::MAX_ACQUIRE_RELEASE_FENCE_COUNT

Definition at line 29 of file flatland_connection.h.

kTextInputActionDone

constexpr char flutter_runner::kTextInputActionDone[] = "TextInputAction.done"

staticconstexpr

Definition at line 29 of file text_delegate.cc.

kTextInputActionGo

constexpr char flutter_runner::kTextInputActionGo[] = "TextInputAction.go"

staticconstexpr

Definition at line 31 of file text_delegate.cc.

kTextInputActionNewline

constexpr char flutter_runner::kTextInputActionNewline[] = "TextInputAction.newline"

staticconstexpr

Definition at line 30 of file text_delegate.cc.

kTextInputActionNext

constexpr char flutter_runner::kTextInputActionNext[] = "TextInputAction.next"

staticconstexpr

Definition at line 32 of file text_delegate.cc.

kTextInputActionNone

constexpr char flutter_runner::kTextInputActionNone[] = "TextInputAction.none"

staticconstexpr

Definition at line 34 of file text_delegate.cc.

kTextInputActionPrevious

constexpr char flutter_runner::kTextInputActionPrevious[] = "TextInputAction.previous"

staticconstexpr

Definition at line 33 of file text_delegate.cc.

kTextInputActionSearch

constexpr char flutter_runner::kTextInputActionSearch[] = "TextInputAction.search"

staticconstexpr

Definition at line 35 of file text_delegate.cc.

kTextInputActionSend

constexpr char flutter_runner::kTextInputActionSend[] = "TextInputAction.send"

staticconstexpr

Definition at line 36 of file text_delegate.cc.

kTextInputActionUnspecified

constexpr char flutter_runner::kTextInputActionUnspecified[]

staticconstexpr

Initial value:

=
    "TextInputAction.unspecified"

Definition at line 37 of file text_delegate.cc.

kTextInputChannel

constexpr char flutter_runner::kTextInputChannel[] = "flutter/textinput"

constexpr

The channel name used for text editing platofrm messages.

Definition at line 27 of file text_delegate.h.