dart_utils Namespace Reference

Classes
class	BuildInfo
class	BuildInfoTest
class	ElfSnapshot
class	MappedResource
class	RootInspectNode
class	RunnerTemp
class	VMServiceObject

Functions
	TEST_F (BuildInfoTest, AllPropertiesAreDefined)
	TEST_F (BuildInfoTest, AllPropertiesAreDumped)
bool	ReadFileToString (const std::string &path, std::string *result)
bool	ReadFileToStringAt (int dirfd, const std::string &path, std::string *result)
bool	WriteFile (const std::string &path, const char *data, ssize_t size)
void	HandleIfException (std::shared_ptr<::sys::ServiceDirectory > services, const std::string &component_url, Dart_Handle result)
void	HandleException (std::shared_ptr<::sys::ServiceDirectory > services, const std::string &component_url, const std::string &error, const std::string &stack_trace)
void	Check (bool condition, const char *tag, const char *message="")
template<size_t SIZE, typename T >
size_t	ArraySize (T(&array)[SIZE])
static bool	OpenVmo (fuchsia::mem::Buffer *resource_vmo, fdio_ns_t *namespc, const std::string &path, bool executable)
static int	OpenFdExec (const std::string &path, int dirfd)
bool	VmoFromFilename (const std::string &filename, bool executable, fuchsia::mem::Buffer *buffer)
bool	VmoFromFilenameAt (int dirfd, const std::string &filename, bool executable, fuchsia::mem::Buffer *buffer)
zx_status_t	IsSizeValid (const fuchsia::mem::Buffer &buffer, bool *is_valid)

Function Documentation

ArraySize()

template<size_t SIZE, typename T >

size_t dart_utils::ArraySize ( T(&)  array[SIZE] )

inline

Definition at line 26 of file inlines.h.

Referenced by dart_runner::DartRunner::DartRunner(), dart_runner::DartComponentController::Main(), and dart_runner::DartComponentControllerV2::Run().

                                          {
  return SIZE;
}

Check()

void dart_utils::Check ( bool  condition, const char *  tag, const char *  message = ""  )

inline

Definition at line 12 of file inlines.h.

Referenced by base::internal::CheckMathOp(), base::internal::DstRangeRelationToSrcRange(), OpenFdExec(), OpenVmo(), and flutter_runner::VulkanSurface::SignalWritesFinished().

                                                                             {
  if (!condition) {
    FX_LOG(FATAL, tag, message);
  }
}

HandleException()

void dart_utils::HandleException	(	std::shared_ptr<::sys::ServiceDirectory >	services,
		const std::string &	component_url,
		const std::string &	error,
		const std::string &	stack_trace
	)

Definition at line 108 of file handle_exception.cc.

References LOG_TAG, and result.

Referenced by flutter_runner::ComponentV1::Create(), flutter_runner::ComponentV2::Create(), and HandleIfException().

                                                   {
  fuchsia::feedback::CrashReport crash_report =
      BuildCrashReport(component_url, error, stack_trace);

  fuchsia::feedback::CrashReporterPtr crash_reporter =
      services->Connect<fuchsia::feedback::CrashReporter>();
  crash_reporter->File(
      std::move(crash_report),
      [](fuchsia::feedback::CrashReporter_File_Result result) {
        if (result.is_err()) {
          FX_LOGF(ERROR, LOG_TAG, "Failed to report Dart exception: %d (%s)",
                  result.err(), zx_status_get_string(result.err()));
        }
      });
}

HandleIfException()

void dart_utils::HandleIfException	(	std::shared_ptr<::sys::ServiceDirectory >	services,
		const std::string &	component_url,
		Dart_Handle	result
	)

Definition at line 93 of file handle_exception.cc.

References HandleException(), and tonic::StdStringFromDart().

Referenced by dart_runner::DartComponentController::Main(), and dart_runner::DartComponentControllerV2::Run().

                                           {
  if (!Dart_IsError(result) || !Dart_ErrorHasException(result)) {
    return;
  }

  const std::string error =
      tonic::StdStringFromDart(Dart_ToString(Dart_ErrorGetException(result)));
  const std::string stack_trace =
      tonic::StdStringFromDart(Dart_ToString(Dart_ErrorGetStackTrace(result)));

  return HandleException(services, component_url, error, stack_trace);
}

IsSizeValid()

zx_status_t dart_utils::IsSizeValid	(	const fuchsia::mem::Buffer &	buffer,
		bool *	is_valid
	)

Definition at line 95 of file vmo.cc.

                                                                        {
  size_t vmo_size;
  zx_status_t status = buffer.vmo.get_size(&vmo_size);
  if (status == ZX_OK) {
    *is_valid = vmo_size >= buffer.size;
  } else {
    *is_valid = false;
  }
  return status;
}

OpenFdExec()

static int dart_utils::OpenFdExec ( const std::string &  path, int  dirfd  )

static

Definition at line 105 of file mapped_resource.cc.

References Check(), LOG_TAG, and result.

Referenced by dart_utils::ElfSnapshot::Load().

                                                        {
  int fd = -1;
  zx_status_t result;
  if (dirfd == AT_FDCWD) {
    // fdio_open_fd_at does not support AT_FDCWD, by design.  Use fdio_open_fd
    // and expect an absolute path for that usage pattern.
    dart_utils::Check(path[0] == '/', LOG_TAG);
    result = fdio_open_fd(
        path.c_str(),
        fuchsia::io::OPEN_RIGHT_READABLE | fuchsia::io::OPEN_RIGHT_EXECUTABLE,
        &fd);
  } else {
    dart_utils::Check(path[0] != '/', LOG_TAG);
    result = fdio_open_fd_at(
        dirfd, path.c_str(),
        fuchsia::io::OPEN_RIGHT_READABLE | fuchsia::io::OPEN_RIGHT_EXECUTABLE,
        &fd);
  }
  if (result != ZX_OK) {
    FX_LOGF(ERROR, LOG_TAG, "fdio_open_fd_at(%s) failed: %s", path.c_str(),
            zx_status_get_string(result));
    return -1;
  }
  return fd;
}

OpenVmo()

static bool dart_utils::OpenVmo ( fuchsia::mem::Buffer *  resource_vmo, fdio_ns_t *  namespc, const std::string &  path, bool  executable  )

static

Definition at line 29 of file mapped_resource.cc.

References Check(), LOG_TAG, result, VmoFromFilename(), and VmoFromFilenameAt().

Referenced by dart_utils::MappedResource::LoadFromNamespace().

                                     {
  TRACE_DURATION("dart", "LoadFromNamespace", "path", path);

  if (namespc == nullptr) {
    // Opening a file in the root namespace expects an absolute path.
    dart_utils::Check(path[0] == '/', LOG_TAG);
    if (!VmoFromFilename(path, executable, resource_vmo)) {
      return false;
    }
  } else {
    // openat of a path with a leading '/' ignores the namespace fd.
    // require a relative path.
    dart_utils::Check(path[0] != '/', LOG_TAG);

    auto root_dir = fdio_ns_opendir(namespc);
    if (root_dir < 0) {
      FX_LOG(ERROR, LOG_TAG, "Failed to open namespace directory");
      return false;
    }

    bool result =
        dart_utils::VmoFromFilenameAt(root_dir, path, executable, resource_vmo);
    close(root_dir);
    if (!result) {
      return result;
    }
  }

  return true;
}

ReadFileToString()

bool dart_utils::ReadFileToString	(	const std::string &	path,
		std::string *	result
	)

Definition at line 56 of file files.cc.

References ReadFileToStringAt().

Referenced by flutter_runner::ComponentV1::Create(), flutter_runner::ComponentV2::Create(), RegisterProfilerSymbols(), and flutter_runner::RegisterProfilerSymbols().

                                                                {
  return ReadFileToStringAt(AT_FDCWD, path, result);
}

ReadFileToStringAt()

bool dart_utils::ReadFileToStringAt	(	int	dirfd,
		const std::string &	path,
		std::string *	result
	)

Definition at line 60 of file files.cc.

Referenced by ReadFileToString().

                                           {
  int fd = openat(dirfd, path.c_str(), O_RDONLY);
  bool status = ReadFileDescriptor(fd, result);
  close(fd);
  return status;
}

TEST_F() [1/2]

dart_utils::TEST_F	(	BuildInfoTest	,
		AllPropertiesAreDefined
	)

Definition at line 37 of file build_info_unittests.cc.

References dart_utils::BuildInfo::DartSdkGitRevision(), dart_utils::BuildInfo::DartSdkSemanticVersion(), dart_utils::BuildInfo::FlutterEngineGitRevision(), and dart_utils::BuildInfo::FuchsiaSdkVersion().

                                               {
  EXPECT_NE(BuildInfo::DartSdkGitRevision(), "{{DART_SDK_GIT_REVISION}}");
  EXPECT_NE(BuildInfo::DartSdkSemanticVersion(),
            "{{DART_SDK_SEMANTIC_VERSION}}");
  EXPECT_NE(BuildInfo::FlutterEngineGitRevision(),
            "{{FLUTTER_ENGINE_GIT_REVISION}}");
  EXPECT_NE(BuildInfo::FuchsiaSdkVersion(), "{{FUCHSIA_SDK_VERSION}}");
}

TEST_F() [2/2]

dart_utils::TEST_F	(	BuildInfoTest	,
		AllPropertiesAreDumped
	)

Definition at line 46 of file build_info_unittests.cc.

References checkProperty(), dart_utils::RootInspectNode::CreateRootChild(), dart_utils::BuildInfo::DartSdkGitRevision(), dart_utils::BuildInfo::DartSdkSemanticVersion(), dart_utils::BuildInfo::Dump(), dart_utils::BuildInfo::FlutterEngineGitRevision(), dart_utils::BuildInfo::FuchsiaSdkVersion(), dart_utils::RootInspectNode::GetInspector(), inspect_node_name, and node.

                                              {
  inspect::Node node =
      dart_utils::RootInspectNode::CreateRootChild(inspect_node_name);
  BuildInfo::Dump(node);
  inspect::Hierarchy root =
      inspect::ReadFromVmo(
          std::move(
              dart_utils::RootInspectNode::GetInspector()->DuplicateVmo()))
          .take_value();
  checkProperty(root, "dart_sdk_git_revision", BuildInfo::DartSdkGitRevision());
  checkProperty(root, "dart_sdk_semantic_version",
                BuildInfo::DartSdkSemanticVersion());
  checkProperty(root, "flutter_engine_git_revision",
                BuildInfo::FlutterEngineGitRevision());
  checkProperty(root, "fuchsia_sdk_version", BuildInfo::FuchsiaSdkVersion());
}

VmoFromFilename()

bool dart_utils::VmoFromFilename	(	const std::string &	filename,
		bool	executable,
		fuchsia::mem::Buffer *	buffer
	)

Definition at line 54 of file vmo.cc.

References flags, LOG_TAG, and result.

Referenced by OpenVmo().

                                               {
  // Note: the implementation here cannot be shared with VmoFromFilenameAt
  // because fdio_open_fd_at does not aim to provide POSIX compatibility, and
  // thus does not handle AT_FDCWD as dirfd.
  uint32_t flags = fuchsia::io::OPEN_RIGHT_READABLE |
                   (executable ? fuchsia::io::OPEN_RIGHT_EXECUTABLE : 0);
  zx_status_t status;
  int fd;

  status = fdio_open_fd(filename.c_str(), flags, &fd);
  if (status != ZX_OK) {
    FX_LOGF(ERROR, LOG_TAG, "fdio_open_fd(\"%s\", %08x) failed: %s",
            filename.c_str(), flags, zx_status_get_string(status));
    return false;
  }
  bool result = VmoFromFd(fd, executable, buffer);
  close(fd);
  return result;
}

VmoFromFilenameAt()

bool dart_utils::VmoFromFilenameAt	(	int	dirfd,
		const std::string &	filename,
		bool	executable,
		fuchsia::mem::Buffer *	buffer
	)

Definition at line 76 of file vmo.cc.

References flags, LOG_TAG, and result.

Referenced by OpenVmo().

                                                 {
  uint32_t flags = fuchsia::io::OPEN_RIGHT_READABLE |
                   (executable ? fuchsia::io::OPEN_RIGHT_EXECUTABLE : 0);
  zx_status_t status;
  int fd;
  status = fdio_open_fd_at(dirfd, filename.c_str(), flags, &fd);
  if (status != ZX_OK) {
    FX_LOGF(ERROR, LOG_TAG, "fdio_open_fd_at(%d, \"%s\", %08x) failed: %s",
            dirfd, filename.c_str(), flags, zx_status_get_string(status));
    return false;
  }
  bool result = VmoFromFd(fd, executable, buffer);
  close(fd);
  return result;
}

WriteFile()

bool dart_utils::WriteFile	(	const std::string &	path,
		const char *	data,
		ssize_t	size
	)

Definition at line 69 of file files.cc.

                                                                      {
  int fd = openat(AT_FDCWD, path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0666);
  if (fd < 0) {
    return false;
  }
  bool status = WriteFileDescriptor(fd, data, size);
  close(fd);
  return status;
}