mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan 

# ignore-this-changeset

Differential Revision: https://phabricator.services.mozilla.com/D58175

--HG--
extra : moz-landing-system : lando
This commit is contained in:
Sylvestre Ledru 2020-01-09 21:50:11 +00:00
Родитель 4a2545c164
Коммит c521758c5e
52 изменённых файлов: 793 добавлений и 843 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
accessible/base/nsAccessibilityService.h
Просмотреть файл

@ -31,7 +31,7 @@ class PresShell;
namespace dom {
class DOMStringList;
class Element;
}
} // namespace dom
namespace a11y {

2
browser/app/nsBrowserApp.cpp
Просмотреть файл

@ -262,7 +262,7 @@ int main(int argc, char* argv[], char* envp[]) {
// argc & argv will be updated with the values passing from the
// chrome process. With the new values, this function
// continues the reset of the code acting as a content process.
if(gBootstrap->XRE_ForkServer(&argc, &argv)) {
if (gBootstrap->XRE_ForkServer(&argc, &argv)) {
// Return from the fork server in the fork server process.
// Stop the fork server.
gBootstrap->NS_LogTerm();

8
browser/app/winlauncher/DllBlocklistInit.cpp
Просмотреть файл

@ -65,11 +65,11 @@ LauncherVoidResultWithLineInfo InitializeDllBlocklistOOP(
// safely make its ntdll calls.
HMODULE ourModule;
#if defined(_MSC_VER)
# if defined(_MSC_VER)
ourModule = reinterpret_cast<HMODULE>(&__ImageBase);
#else
# else
ourModule = ::GetModuleHandleW(nullptr);
#endif // defined(_MSC_VER)
# endif // defined(_MSC_VER)
mozilla::nt::PEHeaders ourExeImage(ourModule);
if (!ourExeImage) {
@ -84,7 +84,7 @@ LauncherVoidResultWithLineInfo InitializeDllBlocklistOOP(
return importDirRestored;
}
Maybe<Span<IMAGE_THUNK_DATA>> ntdllThunks =
Maybe<Span<IMAGE_THUNK_DATA> > ntdllThunks =
ourExeImage.GetIATThunksForModule("ntdll.dll");
if (!ntdllThunks) {
return LAUNCHER_ERROR_FROM_WIN32(ERROR_INVALID_DATA);

7
caps/ContentPrincipal.h
Просмотреть файл

@ -57,7 +57,12 @@ class ContentPrincipal final : public BasePrincipal {
virtual nsresult PopulateJSONObject(Json::Value& aObject) override;
// Serializable keys are the valid enum fields the serialization supports
enum SerializableKeys : uint8_t { eURI = 0, eDomain, eSuffix, eMax = eSuffix };
enum SerializableKeys : uint8_t {
eURI = 0,
eDomain,
eSuffix,
eMax = eSuffix
};
typedef mozilla::BasePrincipal::KeyValT<SerializableKeys> KeyVal;
static already_AddRefed<BasePrincipal> FromProperties(

1
docshell/shistory/ChildSHistory.h
Просмотреть файл

@ -37,7 +37,6 @@ namespace dom {
class ChildSHistory : public nsISupports, public nsWrapperCache {
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ChildSHistory)
nsISupports* GetParentObject() const;

4
dom/base/ScreenOrientation.cpp
Просмотреть файл

@ -615,9 +615,9 @@ ScreenOrientation::VisibleEventListener::HandleEvent(Event* aEvent) {
BrowsingContext* bc = doc->GetBrowsingContext();
if (bc && bc->GetCurrentOrientationType() !=
orientation->DeviceType(CallerType::System)) {
orientation->DeviceType(CallerType::System)) {
bc->SetCurrentOrientation(orientation->DeviceType(CallerType::System),
orientation->DeviceAngle(CallerType::System));
orientation->DeviceAngle(CallerType::System));
nsCOMPtr<nsIRunnable> runnable =
orientation->DispatchChangeEventAndResolvePromise();

20
dom/bindings/BindingDeclarations.h
Просмотреть файл

@ -188,19 +188,19 @@ class Optional : public Optional_base<T, T> {
};
template <typename T>
class Optional<JS::Handle<T> >
: public Optional_base<JS::Handle<T>, JS::Rooted<T> > {
class Optional<JS::Handle<T>>
: public Optional_base<JS::Handle<T>, JS::Rooted<T>> {
public:
MOZ_ALLOW_TEMPORARY Optional()
: Optional_base<JS::Handle<T>, JS::Rooted<T> >() {}
: Optional_base<JS::Handle<T>, JS::Rooted<T>>() {}
explicit Optional(JSContext* cx)
: Optional_base<JS::Handle<T>, JS::Rooted<T> >() {
: Optional_base<JS::Handle<T>, JS::Rooted<T>>() {
this->Construct(cx);
}
Optional(JSContext* cx, const T& aValue)
: Optional_base<JS::Handle<T>, JS::Rooted<T> >(cx, aValue) {}
: Optional_base<JS::Handle<T>, JS::Rooted<T>>(cx, aValue) {}
// Override the const Value() to return the right thing so we're not
// returning references to temporaries.
@ -249,7 +249,7 @@ class Optional<JS::Value> {
template <typename U>
class NonNull;
template <typename T>
class Optional<NonNull<T> > : public Optional_base<T, NonNull<T> > {
class Optional<NonNull<T>> : public Optional_base<T, NonNull<T>> {
public:
// We want our Value to actually return a non-const reference, even
// if we're const. At least for things that are normally pointer
@ -264,7 +264,7 @@ class Optional<NonNull<T> > : public Optional_base<T, NonNull<T> > {
// A specialization of Optional for OwningNonNull that lets us get a
// T& from Value()
template <typename T>
class Optional<OwningNonNull<T> > : public Optional_base<T, OwningNonNull<T> > {
class Optional<OwningNonNull<T>> : public Optional_base<T, OwningNonNull<T>> {
public:
// We want our Value to actually return a non-const reference, even
// if we're const. At least for things that are normally pointer
@ -412,8 +412,10 @@ template <typename T>
class Sequence : public FallibleTArray<T> {
public:
Sequence() : FallibleTArray<T>() {}
MOZ_IMPLICIT Sequence(FallibleTArray<T>&& aArray) : FallibleTArray<T>(std::move(aArray)) {}
MOZ_IMPLICIT Sequence(nsTArray<T>&& aArray) : FallibleTArray<T>(std::move(aArray)) {}
MOZ_IMPLICIT Sequence(FallibleTArray<T>&& aArray)
: FallibleTArray<T>(std::move(aArray)) {}
MOZ_IMPLICIT Sequence(nsTArray<T>&& aArray)
: FallibleTArray<T>(std::move(aArray)) {}
};
inline nsWrapperCache* GetWrapperCache(nsWrapperCache* cache) { return cache; }

3
dom/bindings/test/WrapperCachedNonISupportsTestInterface.h
Просмотреть файл

@ -27,7 +27,8 @@ class WrapperCachedNonISupportsTestInterface final : public nsWrapperCache {
public:
WrapperCachedNonISupportsTestInterface() {}
static already_AddRefed<WrapperCachedNonISupportsTestInterface> Constructor(const GlobalObject& aGlobalObject);
static already_AddRefed<WrapperCachedNonISupportsTestInterface> Constructor(
const GlobalObject& aGlobalObject);
protected:
~WrapperCachedNonISupportsTestInterface() {}

4
dom/localstorage/LSSnapshot.h
Просмотреть файл

@ -28,8 +28,8 @@ class LSSnapshotInitInfo;
class LSWriteAndNotifyInfo;
class SnapshotWriteOptimizer;
template <typename> class Optional;
template <typename>
class Optional;
class LSSnapshot final : public nsIRunnable {
public:

3
dom/localstorage/LSValue.h
Просмотреть файл

@ -13,7 +13,8 @@
class mozIStorageStatement;
namespace IPC {
template <typename> struct ParamTraits;
template <typename>
struct ParamTraits;
}
namespace mozilla {

40
dom/media/FileBlockCache.cpp
Просмотреть файл

@ -114,13 +114,14 @@ void FileBlockCache::Flush() {
// Dispatch a task so we won't clear the arrays while PerformBlockIOs() is
// dropping the data lock and cause InvalidArrayIndex.
RefPtr<FileBlockCache> self = this;
mBackgroundET->Dispatch(NS_NewRunnableFunction("FileBlockCache::Flush", [self]() {
MutexAutoLock mon(self->mDataMutex);
// Just discard pending changes, assume MediaCache won't read from
// blocks it hasn't written to.
self->mChangeIndexList.clear();
self->mBlockChanges.Clear();
}));
mBackgroundET->Dispatch(
NS_NewRunnableFunction("FileBlockCache::Flush", [self]() {
MutexAutoLock mon(self->mDataMutex);
// Just discard pending changes, assume MediaCache won't read from
// blocks it hasn't written to.
self->mChangeIndexList.clear();
self->mBlockChanges.Clear();
}));
}
size_t FileBlockCache::GetMaxBlocks(size_t aCacheSizeInKB) const {
@ -175,18 +176,19 @@ void FileBlockCache::Close() {
}
// Let the thread close the FD, and then trigger its own shutdown.
// Note that mBackgroundET is now empty, so no other task will be posted there.
// Also mBackgroundET and mFD are empty and therefore can be reused immediately.
nsresult rv = thread->Dispatch(
NS_NewRunnableFunction(
"FileBlockCache::Close",
[thread, fd] {
if (fd) {
CloseFD(fd);
}
// No need to shutdown background task queues.
}),
NS_DISPATCH_EVENT_MAY_BLOCK);
// Note that mBackgroundET is now empty, so no other task will be posted
// there. Also mBackgroundET and mFD are empty and therefore can be reused
// immediately.
nsresult rv = thread->Dispatch(NS_NewRunnableFunction("FileBlockCache::Close",
[thread, fd] {
if (fd) {
CloseFD(fd);
}
// No need to shutdown
// background task
// queues.
}),
NS_DISPATCH_EVENT_MAY_BLOCK);
NS_ENSURE_SUCCESS_VOID(rv);
}

11
dom/media/hls/HLSDemuxer.cpp
Просмотреть файл

@ -363,8 +363,7 @@ void HLSTrackDemuxer::UpdateMediaInfo(int index) {
audioInfo->mBitDepth = audioInfoObj->BitDepth();
audioInfo->mMimeType =
NS_ConvertUTF16toUTF8(audioInfoObj->MimeType()->ToString());
audioInfo->mDuration =
TimeUnit::FromMicroseconds(audioInfoObj->Duration());
audioInfo->mDuration = TimeUnit::FromMicroseconds(audioInfoObj->Duration());
jni::ByteArray::LocalRef csdBytes = audioInfoObj->CodecSpecificData();
if (csdBytes) {
auto&& csd = csdBytes->GetElements();
@ -389,11 +388,9 @@ void HLSTrackDemuxer::UpdateMediaInfo(int index) {
videoInfo->mDisplay.height = videoInfoObj->PictureHeight();
videoInfo->mMimeType =
NS_ConvertUTF16toUTF8(videoInfoObj->MimeType()->ToString());
videoInfo->mDuration =
TimeUnit::FromMicroseconds(videoInfoObj->Duration());
HLS_DEBUG("HLSTrackDemuxer",
"Update video info (%d) / I(%dx%d) / D(%dx%d)", index,
videoInfo->mImage.width, videoInfo->mImage.height,
videoInfo->mDuration = TimeUnit::FromMicroseconds(videoInfoObj->Duration());
HLS_DEBUG("HLSTrackDemuxer", "Update video info (%d) / I(%dx%d) / D(%dx%d)",
index, videoInfo->mImage.width, videoInfo->mImage.height,
videoInfo->mDisplay.width, videoInfo->mDisplay.height);
}
}

3
dom/security/nsContentSecurityUtils.h
Просмотреть файл

@ -23,7 +23,8 @@ typedef mozilla::Pair<nsCString, mozilla::Maybe<nsString>>
class nsContentSecurityUtils {
public:
static FilenameTypeAndDetails FilenameToFilenameType(const nsString& fileName);
static FilenameTypeAndDetails FilenameToFilenameType(
const nsString& fileName);
static bool IsEvalAllowed(JSContext* cx, bool aIsSystemPrincipal,
const nsAString& aScript);
static void NotifyEvalUsage(bool aIsSystemPrincipal,

3
gfx/2d/ScaleFactors2D.h
Просмотреть файл

@ -53,7 +53,8 @@ struct ScaleFactors2D {
return ScaleFactor<src, dst>(xScale);
}
ScaleFactors2D<src, dst>& operator=(const ScaleFactors2D<src, dst>&) = default;
ScaleFactors2D<src, dst>& operator=(const ScaleFactors2D<src, dst>&) =
default;
bool operator==(const ScaleFactors2D<src, dst>& aOther) const {
return xScale == aOther.xScale && yScale == aOther.yScale;

2
gfx/layers/ScrollableLayerGuid.h
Просмотреть файл

@ -11,7 +11,7 @@
#include "mozilla/HashFunctions.h" // for HashGeneric
#include "mozilla/gfx/Logging.h" // for Log
#include "mozilla/layers/LayersTypes.h" // for LayersId
#include "nsHashKeys.h" // for nsPrintfCString
#include "nsHashKeys.h" // for nsPrintfCString
#include "nsPrintfCString.h" // for nsPrintfCString
namespace mozilla {

3
image/imgTools.cpp
Просмотреть файл

@ -86,7 +86,8 @@ class ImageDecoderListener final : public nsIStreamListener,
: mURI(aURI),
mImage(nullptr),
mCallback(aCallback),
mObserver(aObserver ? new NotificationObserverWrapper(aObserver) : nullptr) {
mObserver(aObserver ? new NotificationObserverWrapper(aObserver)
: nullptr) {
MOZ_ASSERT(NS_IsMainThread());
}

9
ipc/app/MozillaRuntimeMain.cpp
Просмотреть файл

@ -13,8 +13,7 @@
using namespace mozilla;
static bool
UseForkServer(int argc, char* argv[]) {
static bool UseForkServer(int argc, char* argv[]) {
#if defined(MOZ_ENABLE_FORKSERVER)
return strcmp(argv[argc - 1], "forkserver") == 0;
#else
@ -22,8 +21,8 @@ UseForkServer(int argc, char* argv[]) {
#endif
}
static int
RunForkServer(Bootstrap::UniquePtr&& bootstrap, int argc, char* argv[]) {
static int RunForkServer(Bootstrap::UniquePtr&& bootstrap, int argc,
char* argv[]) {
#if defined(MOZ_ENABLE_FORKSERVER)
int ret = 0;
@ -38,7 +37,7 @@ RunForkServer(Bootstrap::UniquePtr&& bootstrap, int argc, char* argv[]) {
// argc & argv will be updated with the values passing from the
// chrome process. With the new values, this function
// continues the reset of the code acting as a content process.
if(bootstrap->XRE_ForkServer(&argc, &argv)) {
if (bootstrap->XRE_ForkServer(&argc, &argv)) {
// Return from the fork server in the fork server process.
// Stop the fork server.
} else {

16
ipc/chromium/src/base/process_util.h
Просмотреть файл

@ -44,15 +44,15 @@
#include "mozilla/ipc/EnvironmentMap.h"
#if defined(MOZ_ENABLE_FORKSERVER)
#include "nsString.h"
#include "mozilla/Tuple.h"
#include "mozilla/ipc/FileDescriptorShuffle.h"
# include "nsString.h"
# include "mozilla/Tuple.h"
# include "mozilla/ipc/FileDescriptorShuffle.h"
namespace mozilla {
namespace ipc {
class FileDescriptor;
}
}
} // namespace mozilla
#endif
#if defined(OS_MACOSX)
@ -195,7 +195,7 @@ EnvironmentArray BuildEnvironmentArray(const environment_map& env_vars_to_set);
* and second step, that is why two steps.
*/
class AppProcessBuilder {
public:
public:
AppProcessBuilder();
// This function will fork a new process for use as a
// content processes.
@ -209,10 +209,10 @@ public:
// The message loop may allocate resources like file descriptors.
// If this function is called before the end of the loop, the
// reosurces may be destroyed while the loop is still alive.
void InitAppProcess(int *argcp, char*** argvp);
void InitAppProcess(int* argcp, char*** argvp);
private:
void ReplaceArguments(int *argcp, char*** argvp);
private:
void ReplaceArguments(int* argcp, char*** argvp);
mozilla::ipc::FileDescriptorShuffle shuffle_;
std::vector<std::string> argv_;

81
ipc/chromium/src/base/process_util_linux.cc
Просмотреть файл

@ -14,18 +14,18 @@
#include "algorithm"
#if defined(MOZ_ENABLE_FORKSERVER)
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <stdlib.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <fcntl.h>
# if defined(DEBUG)
#include "base/message_loop.h"
# include "base/message_loop.h"
# endif
#include "mozilla/DebugOnly.h"
#include "mozilla/ipc/ForkServiceChild.h"
# include "mozilla/DebugOnly.h"
# include "mozilla/ipc/ForkServiceChild.h"
#include "mozilla/Unused.h"
#include "mozilla/ScopeExit.h"
# include "mozilla/Unused.h"
# include "mozilla/ScopeExit.h"
using namespace mozilla::ipc;
#endif
@ -51,16 +51,14 @@ namespace base {
#if defined(MOZ_ENABLE_FORKSERVER)
static mozilla::StaticAutoPtr<std::vector<int> > sNoCloseFDs;
void
RegisterForkServerNoCloseFD(int fd) {
void RegisterForkServerNoCloseFD(int fd) {
if (!sNoCloseFDs) {
sNoCloseFDs = new std::vector<int>();
}
sNoCloseFDs->push_back(fd);
}
static bool
IsNoCloseFd(int fd) {
static bool IsNoCloseFd(int fd) {
if (!sNoCloseFDs) {
return false;
}
@ -68,19 +66,17 @@ IsNoCloseFd(int fd) {
[fd](int regfd) -> bool { return regfd == fd; });
}
AppProcessBuilder::AppProcessBuilder() {
}
AppProcessBuilder::AppProcessBuilder() {}
static void
ReplaceEnviroment(const LaunchOptions& options) {
static void ReplaceEnviroment(const LaunchOptions& options) {
for (auto& elt : options.env_map) {
setenv(elt.first.c_str(), elt.second.c_str(), 1);
}
}
bool
AppProcessBuilder::ForkProcess(const std::vector<std::string>& argv,
const LaunchOptions& options, ProcessHandle* process_handle) {
bool AppProcessBuilder::ForkProcess(const std::vector<std::string>& argv,
const LaunchOptions& options,
ProcessHandle* process_handle) {
auto cleanFDs = mozilla::MakeScopeExit([&] {
for (auto& elt : options.fds_to_remap) {
auto fd = std::get<0>(elt);
@ -98,16 +94,16 @@ AppProcessBuilder::ForkProcess(const std::vector<std::string>& argv,
fflush(stdout);
fflush(stderr);
#ifdef OS_LINUX
# ifdef OS_LINUX
pid_t pid = options.fork_delegate ? options.fork_delegate->Fork() : fork();
// WARNING: if pid == 0, only async signal safe operations are permitted from
// here until exec or _exit.
//
// Specifically, heap allocation is not safe: the sandbox's fork substitute
// won't run the pthread_atfork handlers that fix up the malloc locks.
#else
# else
pid_t pid = fork();
#endif
# endif
if (pid < 0) {
return false;
@ -127,8 +123,7 @@ AppProcessBuilder::ForkProcess(const std::vector<std::string>& argv,
return true;
}
void
AppProcessBuilder::ReplaceArguments(int *argcp, char*** argvp) {
void AppProcessBuilder::ReplaceArguments(int* argcp, char*** argvp) {
// Change argc & argv of main() with the arguments passing
// through IPC.
char** argv = new char*[argv_.size() + 1];
@ -141,8 +136,7 @@ AppProcessBuilder::ReplaceArguments(int *argcp, char*** argvp) {
*argcp = argv_.size();
}
void
AppProcessBuilder::InitAppProcess(int *argcp, char*** argvp) {
void AppProcessBuilder::InitAppProcess(int* argcp, char*** argvp) {
MOZ_ASSERT(MessageLoop::current() == nullptr,
"The message loop of the main thread should have been destroyed");
@ -157,8 +151,7 @@ AppProcessBuilder::InitAppProcess(int *argcp, char*** argvp) {
}
CloseSuperfluousFds(&shuffle_, [](void* ctx, int fd) {
return static_cast<decltype(&shuffle_)>(ctx)->MapsTo(fd) ||
IsNoCloseFd(fd);
return static_cast<decltype(&shuffle_)>(ctx)->MapsTo(fd) || IsNoCloseFd(fd);
});
// Without this, the destructor of |shuffle_| would try to close FDs
// created by it, but they have been closed by
@ -168,21 +161,16 @@ AppProcessBuilder::InitAppProcess(int *argcp, char*** argvp) {
ReplaceArguments(argcp, argvp);
}
static void
handle_sigchld(int s) {
waitpid(-1, nullptr, WNOHANG);
}
static void handle_sigchld(int s) { waitpid(-1, nullptr, WNOHANG); }
static void
InstallChildSignalHandler() {
static void InstallChildSignalHandler() {
// Since content processes are not children of the chrome process
// any more, the fork server process has to handle SIGCHLD, or
// content process would remain zombie after dead.
signal(SIGCHLD, handle_sigchld);
}
static void
ReserveFileDescriptors() {
static void ReserveFileDescriptors() {
// Reserve the lower positions of the file descriptors to make sure
// debug files and other files don't take these positions. So we
// can keep their file descriptors during CloseSuperfluousFds() with
@ -193,16 +181,14 @@ ReserveFileDescriptors() {
}
}
void
InitForkServerProcess() {
void InitForkServerProcess() {
InstallChildSignalHandler();
ReserveFileDescriptors();
}
static bool
LaunchAppWithForkServer(const std::vector<std::string>& argv,
const LaunchOptions& options,
ProcessHandle* process_handle) {
static bool LaunchAppWithForkServer(const std::vector<std::string>& argv,
const LaunchOptions& options,
ProcessHandle* process_handle) {
MOZ_ASSERT(ForkServiceChild::Get());
nsTArray<nsCString> _argv(argv.size());
@ -217,13 +203,12 @@ LaunchAppWithForkServer(const std::vector<std::string>& argv,
nsCString(vv.second.c_str())));
}
for (auto& fdmapping : options.fds_to_remap) {
fdsremap.AppendElement(mozilla::FdMapping(mozilla::ipc::FileDescriptor(fdmapping.first),
fdmapping.second));
fdsremap.AppendElement(mozilla::FdMapping(
mozilla::ipc::FileDescriptor(fdmapping.first), fdmapping.second));
}
return ForkServiceChild::Get()->SendForkNewSubprocess(_argv, env,
fdsremap,
process_handle);
return ForkServiceChild::Get()->SendForkNewSubprocess(_argv, env, fdsremap,
process_handle);
}
#endif // MOZ_ENABLE_FORKSERVER

4
ipc/chromium/src/base/process_util_posix.cc
Просмотреть файл

@ -213,7 +213,7 @@ bool DidProcessCrash(bool* child_exited, ProcessHandle handle) {
// them.
const int r = kill(handle, 0);
if (r < 0 && errno == ESRCH) {
if (child_exited) *child_exited = true;
if (child_exited) *child_exited = true;
} else {
if (child_exited) *child_exited = false;
}
@ -261,7 +261,7 @@ bool DidProcessCrash(bool* child_exited, ProcessHandle handle) {
if (WIFEXITED(status)) return WEXITSTATUS(status) != 0;
return false;
#endif // MOZ_ENABLE_FORKSERVER
#endif // MOZ_ENABLE_FORKSERVER
}
void FreeEnvVarsArray::operator()(char** array) {

2
ipc/chromium/src/chrome/common/ipc_message.h
Просмотреть файл

@ -33,7 +33,7 @@ namespace mozilla {
namespace ipc {
class MiniTransceiver;
}
}
} // namespace mozilla
class FileDescriptorSet;

4
ipc/glue/FileDescriptorShuffle.h
Просмотреть файл

@ -51,9 +51,7 @@ class FileDescriptorShuffle {
// Forget the information, so that it's destructor will not try to
// delete FDs duped by itself.
void Forget() {
mTempFds.Clear();
}
void Forget() { mTempFds.Clear(); }
private:
nsTArray<std::pair<int, int>> mMapping;

377
ipc/glue/ForkServer.cpp
Просмотреть файл

@ -14,12 +14,11 @@
#include <fcntl.h>
#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
#include "mozilla/SandboxLaunch.h"
# include "mozilla/SandboxLaunch.h"
#endif
#include <algorithm>
namespace mozilla {
namespace ipc {
@ -27,64 +26,59 @@ static const int sClientFd = 3;
LazyLogModule gForkServiceLog("ForkService");
ForkServer::ForkServer() {
}
ForkServer::ForkServer() {}
/**
* Prepare an environment for running a fork server.
*/
void
ForkServer::InitProcess(int* aArgc, char*** aArgv) {
base::InitForkServerProcess();
void ForkServer::InitProcess(int* aArgc, char*** aArgv) {
base::InitForkServerProcess();
int fd = sClientFd;
int fd_flags = fcntl(sClientFd, F_GETFL, 0);
fcntl(fd, F_SETFL, fd_flags & ~O_NONBLOCK);
mTcver = MakeUnique<MiniTransceiver>(fd, DataBufferClear::AfterReceiving);
int fd = sClientFd;
int fd_flags = fcntl(sClientFd, F_GETFL, 0);
fcntl(fd, F_SETFL, fd_flags & ~O_NONBLOCK);
mTcver = MakeUnique<MiniTransceiver>(fd, DataBufferClear::AfterReceiving);
}
/**
* Start providing the service at the IPC channel.
*/
bool
ForkServer::HandleMessages() {
// |sClientFd| is created by an instance of |IPC::Channel|.
// It sends a HELLO automatically.
IPC::Message hello;
mTcver->RecvInfallible(hello,
"Expect to receive a HELLO message from the parent process!");
MOZ_ASSERT(hello.type() == kHELLO_MESSAGE_TYPE);
bool ForkServer::HandleMessages() {
// |sClientFd| is created by an instance of |IPC::Channel|.
// It sends a HELLO automatically.
IPC::Message hello;
mTcver->RecvInfallible(
hello, "Expect to receive a HELLO message from the parent process!");
MOZ_ASSERT(hello.type() == kHELLO_MESSAGE_TYPE);
// Send it back
mTcver->SendInfallible(hello, "Fail to ack the received HELLO!");
// Send it back
mTcver->SendInfallible(hello, "Fail to ack the received HELLO!");
while (true) {
IPC::Message msg;
if (!mTcver->Recv(msg)) {
break;
}
OnMessageReceived(std::move(msg));
if (mAppProcBuilder) {
// New process - child
return false;
}
while (true) {
IPC::Message msg;
if (!mTcver->Recv(msg)) {
break;
}
// Stop the server
return true;
OnMessageReceived(std::move(msg));
if (mAppProcBuilder) {
// New process - child
return false;
}
}
// Stop the server
return true;
}
inline void
CleanCString(nsCString& str) {
char* data;
int sz = str.GetMutableData(&data);
inline void CleanCString(nsCString& str) {
char* data;
int sz = str.GetMutableData(&data);
memset(data, ' ', sz);
memset(data, ' ', sz);
}
inline void
CleanString(std::string& str) {
inline void CleanString(std::string& str) {
const char deadbeef[] =
"\xde\xad\xbe\xef\xde\xad\xbe\xef\xde\xad\xbe\xef\xde\xad\xbe\xef"
"\xde\xad\xbe\xef\xde\xad\xbe\xef\xde\xad\xbe\xef\xde\xad\xbe\xef";
@ -98,97 +92,91 @@ CleanString(std::string& str) {
}
}
inline void
PrepareArguments(std::vector<std::string>& aArgv,
nsTArray<nsCString>& aArgvArray) {
for (auto& elt : aArgvArray) {
aArgv.push_back(elt.get());
CleanCString(elt);
}
inline void PrepareArguments(std::vector<std::string>& aArgv,
nsTArray<nsCString>& aArgvArray) {
for (auto& elt : aArgvArray) {
aArgv.push_back(elt.get());
CleanCString(elt);
}
}
// Prepare aOptions->env_map
inline void
PrepareEnv(base::LaunchOptions* aOptions, nsTArray<EnvVar>& aEnvMap) {
for (auto& elt : aEnvMap) {
nsCString &var = Get<0>(elt);
nsCString &val = Get<1>(elt);
aOptions->env_map[var.get()] = val.get();
CleanCString(var);
CleanCString(val);
}
inline void PrepareEnv(base::LaunchOptions* aOptions,
nsTArray<EnvVar>& aEnvMap) {
for (auto& elt : aEnvMap) {
nsCString& var = Get<0>(elt);
nsCString& val = Get<1>(elt);
aOptions->env_map[var.get()] = val.get();
CleanCString(var);
CleanCString(val);
}
}
// Prepare aOptions->fds_to_remap
inline void
PrepareFdsRemap(base::LaunchOptions* aOptions,
nsTArray<FdMapping>& aFdsRemap) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("fds mapping:"));
for (auto& elt : aFdsRemap) {
// FDs are duplicated here.
int fd = Get<0>(elt).ClonePlatformHandle().release();
std::pair<int, int> fdmap(fd, Get<1>(elt));
aOptions->fds_to_remap.push_back(fdmap);
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("\t%d => %d", fdmap.first, fdmap.second));
}
inline void PrepareFdsRemap(base::LaunchOptions* aOptions,
nsTArray<FdMapping>& aFdsRemap) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("fds mapping:"));
for (auto& elt : aFdsRemap) {
// FDs are duplicated here.
int fd = Get<0>(elt).ClonePlatformHandle().release();
std::pair<int, int> fdmap(fd, Get<1>(elt));
aOptions->fds_to_remap.push_back(fdmap);
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("\t%d => %d", fdmap.first, fdmap.second));
}
}
/**
* Parse a Message to get a list of arguments and fill a LaunchOptions.
*/
inline bool
ParseForkNewSubprocess(IPC::Message& aMsg,
std::vector<std::string>& aArgv,
base::LaunchOptions* aOptions) {
if (aMsg.type() != Msg_ForkNewSubprocess__ID) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("unknown message type %d\n", aMsg.type()));
return false;
}
inline bool ParseForkNewSubprocess(IPC::Message& aMsg,
std::vector<std::string>& aArgv,
base::LaunchOptions* aOptions) {
if (aMsg.type() != Msg_ForkNewSubprocess__ID) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("unknown message type %d\n", aMsg.type()));
return false;
}
PickleIterator iter(aMsg);
nsTArray<nsCString> argv_array;
nsTArray<EnvVar> env_map;
nsTArray<FdMapping> fds_remap;
PickleIterator iter(aMsg);
nsTArray<nsCString> argv_array;
nsTArray<EnvVar> env_map;
nsTArray<FdMapping> fds_remap;
ReadIPDLParamInfallible(&aMsg, &iter, nullptr, &argv_array,
"Error deserializing 'nsCString[]'");
ReadIPDLParamInfallible(&aMsg, &iter, nullptr, &env_map,
"Error deserializing 'EnvVar[]'");
ReadIPDLParamInfallible(&aMsg, &iter, nullptr, &fds_remap,
"Error deserializing 'FdMapping[]'");
aMsg.EndRead(iter, aMsg.type());
ReadIPDLParamInfallible(&aMsg, &iter, nullptr, &argv_array,
"Error deserializing 'nsCString[]'");
ReadIPDLParamInfallible(&aMsg, &iter, nullptr, &env_map,
"Error deserializing 'EnvVar[]'");
ReadIPDLParamInfallible(&aMsg, &iter, nullptr, &fds_remap,
"Error deserializing 'FdMapping[]'");
aMsg.EndRead(iter, aMsg.type());
PrepareArguments(aArgv, argv_array);
PrepareEnv(aOptions, env_map);
PrepareFdsRemap(aOptions, fds_remap);
PrepareArguments(aArgv, argv_array);
PrepareEnv(aOptions, env_map);
PrepareFdsRemap(aOptions, fds_remap);
return true;
return true;
}
inline void
SanitizeBuffers(IPC::Message& aMsg,
std::vector<std::string>& aArgv,
base::LaunchOptions& aOptions) {
// Clean all buffers in the message to make sure content processes
// not peeking others.
auto& blist = aMsg.Buffers();
for (auto itr = blist.Iter();
!itr.Done();
itr.Advance(blist, itr.RemainingInSegment())) {
memset(itr.Data(), 0, itr.RemainingInSegment());
}
inline void SanitizeBuffers(IPC::Message& aMsg, std::vector<std::string>& aArgv,
base::LaunchOptions& aOptions) {
// Clean all buffers in the message to make sure content processes
// not peeking others.
auto& blist = aMsg.Buffers();
for (auto itr = blist.Iter(); !itr.Done();
itr.Advance(blist, itr.RemainingInSegment())) {
memset(itr.Data(), 0, itr.RemainingInSegment());
}
// clean all data string made from the message.
for (auto& var : aOptions.env_map) {
// Do it anyway since it is not going to be used anymore.
CleanString(*const_cast<std::string*>(&var.first));
CleanString(var.second);
}
for (auto& arg : aArgv) {
CleanString(arg);
}
// clean all data string made from the message.
for (auto& var : aOptions.env_map) {
// Do it anyway since it is not going to be used anymore.
CleanString(*const_cast<std::string*>(&var.first));
CleanString(var.second);
}
for (auto& arg : aArgv) {
CleanString(arg);
}
}
/**
@ -198,45 +186,43 @@ SanitizeBuffers(IPC::Message& aMsg,
* It will return in both the fork server process and the new content
* process. |mAppProcBuilder| is null for the fork server.
*/
void
ForkServer::OnMessageReceived(IPC::Message&& message) {
IPC::Message msg(std::move(message));
void ForkServer::OnMessageReceived(IPC::Message&& message) {
IPC::Message msg(std::move(message));
std::vector<std::string> argv;
base::LaunchOptions options;
if (!ParseForkNewSubprocess(msg, argv, &options)) {
return;
}
std::vector<std::string> argv;
base::LaunchOptions options;
if (!ParseForkNewSubprocess(msg, argv, &options)) {
return;
}
#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
mozilla::SandboxLaunchForkServerPrepare(argv, options);
mozilla::SandboxLaunchForkServerPrepare(argv, options);
#endif
base::ProcessHandle child_pid = -1;
mAppProcBuilder = MakeUnique<base::AppProcessBuilder>();
if (!mAppProcBuilder->ForkProcess(argv, options, &child_pid)) {
MOZ_CRASH("fail to fork");
}
MOZ_ASSERT(child_pid >= 0);
base::ProcessHandle child_pid = -1;
mAppProcBuilder = MakeUnique<base::AppProcessBuilder>();
if (!mAppProcBuilder->ForkProcess(argv, options, &child_pid)) {
MOZ_CRASH("fail to fork");
}
MOZ_ASSERT(child_pid >= 0);
if (child_pid == 0) {
// Content process
return;
}
if (child_pid == 0) {
// Content process
return;
}
// Fork server process
// Fork server process
mAppProcBuilder = nullptr;
mAppProcBuilder = nullptr;
IPC::Message reply(MSG_ROUTING_CONTROL, Reply_ForkNewSubprocess__ID);
WriteIPDLParam(&reply, nullptr, child_pid);
mTcver->SendInfallible(reply,
"failed to send a reply message");
IPC::Message reply(MSG_ROUTING_CONTROL, Reply_ForkNewSubprocess__ID);
WriteIPDLParam(&reply, nullptr, child_pid);
mTcver->SendInfallible(reply, "failed to send a reply message");
// Without this, the content processes that is forked later are
// able to read the content of buffers even the buffers have been
// released.
SanitizeBuffers(msg, argv, options);
// Without this, the content processes that is forked later are
// able to read the content of buffers even the buffers have been
// released.
SanitizeBuffers(msg, argv, options);
}
/**
@ -250,66 +236,69 @@ ForkServer::OnMessageReceived(IPC::Message&& message) {
* For the later case, aArgc and aArgv are modified to pass the
* arguments from the chrome process.
*/
bool
ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
bool ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
#ifdef DEBUG
if (getenv("MOZ_FORKSERVER_WAIT_GDB")) {
printf("Waiting for 30 seconds."
" Attach the fork server with gdb %s %d\n",
(*aArgv)[0], base::GetCurrentProcId());
sleep(30);
}
bool sleep_newproc = !!getenv("MOZ_FORKSERVER_WAIT_GDB_NEWPROC");
if (getenv("MOZ_FORKSERVER_WAIT_GDB")) {
printf(
"Waiting for 30 seconds."
" Attach the fork server with gdb %s %d\n",
(*aArgv)[0], base::GetCurrentProcId());
sleep(30);
}
bool sleep_newproc = !!getenv("MOZ_FORKSERVER_WAIT_GDB_NEWPROC");
#endif
// Do this before NS_LogInit() to avoid log files taking lower
// FDs.
ForkServer forkserver;
forkserver.InitProcess(aArgc, aArgv);
// Do this before NS_LogInit() to avoid log files taking lower
// FDs.
ForkServer forkserver;
forkserver.InitProcess(aArgc, aArgv);
XRE_SetProcessType("forkserver");
NS_LogInit();
mozilla::LogModule::Init(0, nullptr);
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("Start a fork server"));
{
DebugOnly<base::ProcessHandle> forkserver_pid = base::GetCurrentProcId();
if (forkserver.HandleMessages()) {
// In the fork server process
// The server has stopped.
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("Terminate the fork server"));
NS_LogTerm();
return true;
}
// Now, we are running in a content process just forked from
// the fork server process.
MOZ_ASSERT(base::GetCurrentProcId() != forkserver_pid);
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("Fork a new content process"));
XRE_SetProcessType("forkserver");
NS_LogInit();
mozilla::LogModule::Init(0, nullptr);
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("Start a fork server"));
{
DebugOnly<base::ProcessHandle> forkserver_pid = base::GetCurrentProcId();
if (forkserver.HandleMessages()) {
// In the fork server process
// The server has stopped.
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("Terminate the fork server"));
NS_LogTerm();
return true;
}
// Now, we are running in a content process just forked from
// the fork server process.
MOZ_ASSERT(base::GetCurrentProcId() != forkserver_pid);
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("Fork a new content process"));
}
#ifdef DEBUG
if (sleep_newproc) {
printf("Waiting for 30 seconds."
" Attach the new process with gdb %s %d\n",
(*aArgv)[0], base::GetCurrentProcId());
sleep(30);
}
if (sleep_newproc) {
printf(
"Waiting for 30 seconds."
" Attach the new process with gdb %s %d\n",
(*aArgv)[0], base::GetCurrentProcId());
sleep(30);
}
#endif
NS_LogTerm();
NS_LogTerm();
MOZ_ASSERT(forkserver.mAppProcBuilder);
// |messageloop| has been destroyed. So, we can intialized the
// process safely. Message loops may allocates some file
// descriptors. If it is destroyed later, it may mess up this
// content process by closing wrong file descriptors.
forkserver.mAppProcBuilder->InitAppProcess(aArgc, aArgv);
forkserver.mAppProcBuilder.reset();
MOZ_ASSERT(forkserver.mAppProcBuilder);
// |messageloop| has been destroyed. So, we can intialized the
// process safely. Message loops may allocates some file
// descriptors. If it is destroyed later, it may mess up this
// content process by closing wrong file descriptors.
forkserver.mAppProcBuilder->InitAppProcess(aArgc, aArgv);
forkserver.mAppProcBuilder.reset();
MOZ_ASSERT(NS_LITERAL_CSTRING("tab") == (*aArgv)[*aArgc - 1], "Only |tab| is allowed!");
MOZ_ASSERT(NS_LITERAL_CSTRING("tab") == (*aArgv)[*aArgc - 1],
"Only |tab| is allowed!");
// Open log files again with right names and the new PID.
nsTraceRefcnt::ResetLogFiles((*aArgv)[*aArgc - 1]);
// Open log files again with right names and the new PID.
nsTraceRefcnt::ResetLogFiles((*aArgv)[*aArgc - 1]);
return false;
return false;
}
}
}
} // namespace ipc
} // namespace mozilla

34
ipc/glue/ForkServer.h
Просмотреть файл

@ -14,31 +14,31 @@ namespace mozilla {
namespace ipc {
class ForkServer {
public:
static const int kHELLO_MESSAGE_TYPE = 65535;
public:
static const int kHELLO_MESSAGE_TYPE = 65535;
ForkServer();
~ForkServer() {};
ForkServer();
~ForkServer(){};
void InitProcess(int* aArgc, char*** aArgv);
bool HandleMessages();
void InitProcess(int* aArgc, char*** aArgv);
bool HandleMessages();
// Called when a message is received.
void OnMessageReceived(IPC::Message&& message);
// Called when a message is received.
void OnMessageReceived(IPC::Message&& message);
static bool RunForkServer(int* aArgc, char*** aArgv);
static bool RunForkServer(int* aArgc, char*** aArgv);
private:
UniquePtr<MiniTransceiver> mTcver;
UniquePtr<base::AppProcessBuilder> mAppProcBuilder;
private:
UniquePtr<MiniTransceiver> mTcver;
UniquePtr<base::AppProcessBuilder> mAppProcBuilder;
};
enum {
Msg_ForkNewSubprocess__ID = 0x7f0, // a random picked number
Reply_ForkNewSubprocess__ID,
Msg_ForkNewSubprocess__ID = 0x7f0, // a random picked number
Reply_ForkNewSubprocess__ID,
};
}
}
} // namespace ipc
} // namespace mozilla
#endif // __FORKSERVER_H_
#endif // __FORKSERVER_H_

192
ipc/glue/ForkServiceChild.cpp
Просмотреть файл

@ -19,97 +19,89 @@ extern LazyLogModule gForkServiceLog;
mozilla::UniquePtr<ForkServiceChild> ForkServiceChild::sForkServiceChild;
void
ForkServiceChild::StartForkServer() {
std::vector<std::string> extraArgs;
void ForkServiceChild::StartForkServer() {
std::vector<std::string> extraArgs;
GeckoChildProcessHost *subprocess =
new GeckoChildProcessHost(GeckoProcessType_ForkServer, false);
subprocess->LaunchAndWaitForProcessHandle(std::move(extraArgs));
GeckoChildProcessHost* subprocess =
new GeckoChildProcessHost(GeckoProcessType_ForkServer, false);
subprocess->LaunchAndWaitForProcessHandle(std::move(extraArgs));
int fd = subprocess->GetChannel()->GetFileDescriptor();
fd = dup(fd); // Dup it because the channel will close it.
int fs_flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, fs_flags & ~O_NONBLOCK);
int fd_flags = fcntl(fd, F_GETFD, 0);
fcntl(fd, F_SETFD, fd_flags | FD_CLOEXEC);
int fd = subprocess->GetChannel()->GetFileDescriptor();
fd = dup(fd); // Dup it because the channel will close it.
int fs_flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, fs_flags & ~O_NONBLOCK);
int fd_flags = fcntl(fd, F_GETFD, 0);
fcntl(fd, F_SETFD, fd_flags | FD_CLOEXEC);
sForkServiceChild = mozilla::MakeUnique<ForkServiceChild>(fd, subprocess);
sForkServiceChild = mozilla::MakeUnique<ForkServiceChild>(fd, subprocess);
// Without doing this, IO thread may intercept messages since the
// IPC::Channel created by it is still open.
subprocess->GetChannel()->Close();
// Without doing this, IO thread may intercept messages since the
// IPC::Channel created by it is still open.
subprocess->GetChannel()->Close();
}
void
ForkServiceChild::StopForkServer() {
sForkServiceChild = nullptr;
}
void ForkServiceChild::StopForkServer() { sForkServiceChild = nullptr; }
ForkServiceChild::ForkServiceChild(int aFd, GeckoChildProcessHost* aProcess)
: mWaitForHello(true)
, mProcess(aProcess) {
mTcver = MakeUnique<MiniTransceiver>(aFd);
: mWaitForHello(true), mProcess(aProcess) {
mTcver = MakeUnique<MiniTransceiver>(aFd);
}
ForkServiceChild::~ForkServiceChild() {
mProcess->Destroy();
close(mTcver->GetFD());
mProcess->Destroy();
close(mTcver->GetFD());
}
bool
ForkServiceChild::SendForkNewSubprocess(const nsTArray<nsCString>& aArgv,
const nsTArray<EnvVar>& aEnvMap,
const nsTArray<FdMapping>& aFdsRemap,
pid_t* aPid) {
if (mWaitForHello) {
// IPC::Channel created by the GeckoChildProcessHost has
// already send a HELLO. It is expected to receive a hello
// message from the fork server too.
IPC::Message hello;
mTcver->RecvInfallible(hello, "Fail to receive HELLO message");
MOZ_ASSERT(hello.type() == ForkServer::kHELLO_MESSAGE_TYPE);
mWaitForHello = false;
}
bool ForkServiceChild::SendForkNewSubprocess(
const nsTArray<nsCString>& aArgv, const nsTArray<EnvVar>& aEnvMap,
const nsTArray<FdMapping>& aFdsRemap, pid_t* aPid) {
if (mWaitForHello) {
// IPC::Channel created by the GeckoChildProcessHost has
// already send a HELLO. It is expected to receive a hello
// message from the fork server too.
IPC::Message hello;
mTcver->RecvInfallible(hello, "Fail to receive HELLO message");
MOZ_ASSERT(hello.type() == ForkServer::kHELLO_MESSAGE_TYPE);
mWaitForHello = false;
}
mRecvPid = -1;
IPC::Message msg(MSG_ROUTING_CONTROL, Msg_ForkNewSubprocess__ID);
mRecvPid = -1;
IPC::Message msg(MSG_ROUTING_CONTROL, Msg_ForkNewSubprocess__ID);
WriteIPDLParam(&msg, nullptr, aArgv);
WriteIPDLParam(&msg, nullptr, aEnvMap);
WriteIPDLParam(&msg, nullptr, aFdsRemap);
if (!mTcver->Send(msg)) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("the pipe to the fork server is closed or having errors"));
return false;
}
WriteIPDLParam(&msg, nullptr, aArgv);
WriteIPDLParam(&msg, nullptr, aEnvMap);
WriteIPDLParam(&msg, nullptr, aFdsRemap);
if (!mTcver->Send(msg)) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("the pipe to the fork server is closed or having errors"));
return false;
}
IPC::Message reply;
if (!mTcver->Recv(reply)) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("the pipe to the fork server is closed or having errors"));
return false;
}
OnMessageReceived(std::move(reply));
IPC::Message reply;
if (!mTcver->Recv(reply)) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("the pipe to the fork server is closed or having errors"));
return false;
}
OnMessageReceived(std::move(reply));
MOZ_ASSERT(mRecvPid != -1);
*aPid = mRecvPid;
return true;
MOZ_ASSERT(mRecvPid != -1);
*aPid = mRecvPid;
return true;
}
void
ForkServiceChild::OnMessageReceived(IPC::Message&& message) {
if (message.type() != Reply_ForkNewSubprocess__ID) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("unknown reply type %d", message.type()));
return;
}
PickleIterator iter__(message);
void ForkServiceChild::OnMessageReceived(IPC::Message&& message) {
if (message.type() != Reply_ForkNewSubprocess__ID) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("unknown reply type %d", message.type()));
return;
}
PickleIterator iter__(message);
if (!ReadIPDLParam(&message, &iter__, nullptr, &mRecvPid)) {
MOZ_CRASH("Error deserializing 'pid_t'");
}
message.EndRead(iter__, message.type());
if (!ReadIPDLParam(&message, &iter__, nullptr, &mRecvPid)) {
MOZ_CRASH("Error deserializing 'pid_t'");
}
message.EndRead(iter__, message.type());
}
NS_IMPL_ISUPPORTS(ForkServerLauncher, nsIObserver)
@ -117,43 +109,41 @@ NS_IMPL_ISUPPORTS(ForkServerLauncher, nsIObserver)
bool ForkServerLauncher::mHaveStartedClient = false;
StaticRefPtr<ForkServerLauncher> ForkServerLauncher::mSingleton;
ForkServerLauncher::ForkServerLauncher() {
}
ForkServerLauncher::ForkServerLauncher() {}
ForkServerLauncher::~ForkServerLauncher() {
}
ForkServerLauncher::~ForkServerLauncher() {}
already_AddRefed<ForkServerLauncher>
ForkServerLauncher::Create() {
if (mSingleton == nullptr) {
mSingleton = new ForkServerLauncher();
}
RefPtr<ForkServerLauncher> launcher = mSingleton;
return launcher.forget();
already_AddRefed<ForkServerLauncher> ForkServerLauncher::Create() {
if (mSingleton == nullptr) {
mSingleton = new ForkServerLauncher();
}
RefPtr<ForkServerLauncher> launcher = mSingleton;
return launcher.forget();
}
NS_IMETHODIMP
ForkServerLauncher::Observe(nsISupports* aSubject,
const char* aTopic,
const char16_t* aData) {
if (!mHaveStartedClient && strcmp(aTopic, NS_XPCOM_STARTUP_CATEGORY) == 0) {
mHaveStartedClient = true;
ForkServiceChild::StartForkServer();
ForkServerLauncher::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aData) {
if (!mHaveStartedClient && strcmp(aTopic, NS_XPCOM_STARTUP_CATEGORY) == 0) {
mHaveStartedClient = true;
ForkServiceChild::StartForkServer();
nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
MOZ_ASSERT(obsSvc != nullptr);
obsSvc->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
}
nsCOMPtr<nsIObserverService> obsSvc =
mozilla::services::GetObserverService();
MOZ_ASSERT(obsSvc != nullptr);
obsSvc->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
}
if (mHaveStartedClient && strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
mHaveStartedClient = false;
ForkServiceChild::StopForkServer();
if (mHaveStartedClient &&
strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
mHaveStartedClient = false;
ForkServiceChild::StopForkServer();
// To make leak checker happy!
mSingleton = nullptr;
}
return NS_OK;
// To make leak checker happy!
mSingleton = nullptr;
}
return NS_OK;
}
}
}
} // namespace ipc
} // namespace mozilla

102
ipc/glue/ForkServiceChild.h
Просмотреть файл

@ -26,72 +26,70 @@ class GeckoChildProcessHost;
* pipe and get the PID of the new process from the reply.
*/
class ForkServiceChild {
public:
ForkServiceChild(int aFd, GeckoChildProcessHost* aProcess);
virtual ~ForkServiceChild();
public:
ForkServiceChild(int aFd, GeckoChildProcessHost* aProcess);
virtual ~ForkServiceChild();
/**
* Ask the fork server to create a new process with given parameters.
*
* The fork server uses |base::LaunchApp()| to create a new
* content process with the following parameters.
*
* \param aArgv assigns |argv| of the content process.
* \param aEnvMap sets |LaunchOptions::env_map|.
* \param aFdsRemap sets |LaunchOptions::fd_to_remap|.
* \param aPid returns the PID of the content process created.
* \return true if success.
*/
bool SendForkNewSubprocess(
const nsTArray<nsCString>& aArgv,
const nsTArray<EnvVar>& aEnvMap,
const nsTArray<FdMapping>& aFdsRemap,
pid_t* aPid);
/**
* Ask the fork server to create a new process with given parameters.
*
* The fork server uses |base::LaunchApp()| to create a new
* content process with the following parameters.
*
* \param aArgv assigns |argv| of the content process.
* \param aEnvMap sets |LaunchOptions::env_map|.
* \param aFdsRemap sets |LaunchOptions::fd_to_remap|.
* \param aPid returns the PID of the content process created.
* \return true if success.
*/
bool SendForkNewSubprocess(const nsTArray<nsCString>& aArgv,
const nsTArray<EnvVar>& aEnvMap,
const nsTArray<FdMapping>& aFdsRemap, pid_t* aPid);
/**
* Create a fork server process and the singleton of this class.
*
* This function uses |GeckoChildProcessHost| to launch the fork
* server, getting the fd of a pipe/socket to the fork server from
* it's |IPC::Channel|.
*/
static void StartForkServer();
static void StopForkServer();
/**
* Return the singleton.
*/
static ForkServiceChild* Get() { return sForkServiceChild.get(); }
/**
* Create a fork server process and the singleton of this class.
*
* This function uses |GeckoChildProcessHost| to launch the fork
* server, getting the fd of a pipe/socket to the fork server from
* it's |IPC::Channel|.
*/
static void StartForkServer();
static void StopForkServer();
/**
* Return the singleton.
*/
static ForkServiceChild* Get() { return sForkServiceChild.get(); }
private:
// Called when a message is received.
void OnMessageReceived(IPC::Message&& message);
private:
// Called when a message is received.
void OnMessageReceived(IPC::Message&& message);
UniquePtr<MiniTransceiver> mTcver;
static UniquePtr<ForkServiceChild> sForkServiceChild;
pid_t mRecvPid;
bool mWaitForHello;
GeckoChildProcessHost* mProcess;
UniquePtr<MiniTransceiver> mTcver;
static UniquePtr<ForkServiceChild> sForkServiceChild;
pid_t mRecvPid;
bool mWaitForHello;
GeckoChildProcessHost* mProcess;
};
/**
* Start a fork server at |xpcom-startup| from the chrome process.
*/
class ForkServerLauncher : public nsIObserver {
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
ForkServerLauncher();
static already_AddRefed<ForkServerLauncher> Create();
ForkServerLauncher();
static already_AddRefed<ForkServerLauncher> Create();
private:
virtual ~ForkServerLauncher();
private:
virtual ~ForkServerLauncher();
static bool mHaveStartedClient;
static StaticRefPtr<ForkServerLauncher> mSingleton;
static bool mHaveStartedClient;
static StaticRefPtr<ForkServerLauncher> mSingleton;
};
}
}
} // namespace ipc
} // namespace mozilla
#endif /* __FORKSERVICE_CHILD_H_ */

6
ipc/glue/GeckoChildProcessHost.cpp
Просмотреть файл

@ -831,7 +831,8 @@ void BaseProcessLauncher::GetChildLogName(const char* origLogName,
//
// Fork server needs a dedicated thread for accessing
// |ForkServiceChild|.
#if defined(XP_WIN) || defined(MOZ_WIDGET_ANDROID) || defined(MOZ_ENABLE_FORKSERVER)
#if defined(XP_WIN) || defined(MOZ_WIDGET_ANDROID) || \
defined(MOZ_ENABLE_FORKSERVER)
static mozilla::StaticMutex gIPCLaunchThreadMutex;
static mozilla::StaticRefPtr<nsIThread> gIPCLaunchThread;
@ -884,7 +885,8 @@ nsCOMPtr<nsIEventTarget> GetIPCLauncher() {
return thread;
}
#else // defined(XP_WIN) || defined(MOZ_WIDGET_ANDROID) || defined(MOZ_ENABLE_FORKSERVER)
#else // defined(XP_WIN) || defined(MOZ_WIDGET_ANDROID) ||
// defined(MOZ_ENABLE_FORKSERVER)
// Other platforms use an on-demand thread pool.

7
ipc/glue/IPDLParamTraits.h
Просмотреть файл

@ -69,10 +69,9 @@ static MOZ_NEVER_INLINE bool ReadIPDLParam(const IPC::Message* aMsg,
}
template <typename P>
static MOZ_NEVER_INLINE bool ReadIPDLParamInfallible(const IPC::Message* aMsg,
PickleIterator* aIter,
IProtocol* aActor, P* aResult,
const char* aCrashMessage) {
static MOZ_NEVER_INLINE bool ReadIPDLParamInfallible(
const IPC::Message* aMsg, PickleIterator* aIter, IProtocol* aActor,
P* aResult, const char* aCrashMessage) {
bool ok = ReadIPDLParam(aMsg, aIter, aActor, aResult);
if (!ok) {
MOZ_CRASH_UNSAFE(aCrashMessage);

318
ipc/glue/MiniTransceiver.cpp
Просмотреть файл

@ -32,214 +32,210 @@ MiniTransceiver::MiniTransceiver(int aFd, DataBufferClear aDataBufClear)
namespace {
/**
* Initialize the IO vector for sending data and the control buffer for sending FDs.
* Initialize the IO vector for sending data and the control buffer for sending
* FDs.
*/
static void
InitMsgHdr(msghdr* aHdr, int aIOVSize, int aMaxNumFds) {
aHdr->msg_name = nullptr;
aHdr->msg_namelen = 0;
aHdr->msg_flags = 0;
static void InitMsgHdr(msghdr* aHdr, int aIOVSize, int aMaxNumFds) {
aHdr->msg_name = nullptr;
aHdr->msg_namelen = 0;
aHdr->msg_flags = 0;
// Prepare the IO vector to receive the content of message.
auto iov = new iovec[aIOVSize];
aHdr->msg_iov = iov;
aHdr->msg_iovlen = aIOVSize;
// Prepare the IO vector to receive the content of message.
auto iov = new iovec[aIOVSize];
aHdr->msg_iov = iov;
aHdr->msg_iovlen = aIOVSize;
// Prepare the control buffer to receive file descriptors.
auto cbuf = new char[CMSG_SPACE(sizeof(int) * aMaxNumFds)];
aHdr->msg_control = cbuf;
aHdr->msg_controllen = CMSG_SPACE(sizeof(int) * aMaxNumFds);
// Prepare the control buffer to receive file descriptors.
auto cbuf = new char[CMSG_SPACE(sizeof(int) * aMaxNumFds)];
aHdr->msg_control = cbuf;
aHdr->msg_controllen = CMSG_SPACE(sizeof(int) * aMaxNumFds);
}
/**
* Delete resources allocated by InitMsgHdr().
*/
static void
DeinitMsgHdr(msghdr* aHdr) {
delete aHdr->msg_iov;
delete static_cast<char*>(aHdr->msg_control);
static void DeinitMsgHdr(msghdr* aHdr) {
delete aHdr->msg_iov;
delete static_cast<char*>(aHdr->msg_control);
}
} // namespace
void MiniTransceiver::PrepareFDs(msghdr* aHdr, IPC::Message& aMsg) {
// Set control buffer to send file descriptors of the Message.
int num_fds = aMsg.file_descriptor_set()->size();
cmsghdr* cmsg = CMSG_FIRSTHDR(aHdr);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
aMsg.file_descriptor_set()->GetDescriptors(
reinterpret_cast<int*>(CMSG_DATA(cmsg)));
// This number will be sent in the header of the message. So, we
// can check it at the other side.
aMsg.header()->num_fds = num_fds;
}
void
MiniTransceiver::PrepareFDs(msghdr* aHdr, IPC::Message& aMsg) {
// Set control buffer to send file descriptors of the Message.
int num_fds = aMsg.file_descriptor_set()->size();
size_t MiniTransceiver::PrepareBuffers(msghdr* aHdr, IPC::Message& aMsg) {
// Set iovec to send for all buffers of the Message.
iovec* iov = aHdr->msg_iov;
size_t iovlen = 0;
size_t bytes_to_send = 0;
for (Pickle::BufferList::IterImpl iter(aMsg.Buffers()); !iter.Done();
iter.Advance(aMsg.Buffers(), iter.RemainingInSegment())) {
char* data = iter.Data();
size_t size = iter.RemainingInSegment();
iov[iovlen].iov_base = data;
iov[iovlen].iov_len = size;
iovlen++;
MOZ_ASSERT(iovlen <= kMaxIOVecSize);
bytes_to_send += size;
}
MOZ_ASSERT(bytes_to_send <= kMaxDataSize);
aHdr->msg_iovlen = iovlen;
cmsghdr *cmsg = CMSG_FIRSTHDR(aHdr);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
aMsg.file_descriptor_set()->GetDescriptors(
reinterpret_cast<int*>(CMSG_DATA(cmsg)));
// This number will be sent in the header of the message. So, we
// can check it at the other side.
aMsg.header()->num_fds = num_fds;
return bytes_to_send;
}
size_t
MiniTransceiver::PrepareBuffers(msghdr* aHdr, IPC::Message& aMsg) {
// Set iovec to send for all buffers of the Message.
iovec *iov = aHdr->msg_iov;
size_t iovlen = 0;
size_t bytes_to_send = 0;
for (Pickle::BufferList::IterImpl iter(aMsg.Buffers());
!iter.Done();
iter.Advance(aMsg.Buffers(), iter.RemainingInSegment())) {
char* data = iter.Data();
size_t size = iter.RemainingInSegment();
iov[iovlen].iov_base = data;
iov[iovlen].iov_len = size;
iovlen++;
MOZ_ASSERT(iovlen <= kMaxIOVecSize);
bytes_to_send += size;
}
MOZ_ASSERT(bytes_to_send <= kMaxDataSize);
aHdr->msg_iovlen = iovlen;
return bytes_to_send;
}
bool
MiniTransceiver::Send(IPC::Message& aMsg) {
bool MiniTransceiver::Send(IPC::Message& aMsg) {
#ifdef DEBUG
if (mState == STATE_SENDING) {
MOZ_CRASH("STATE_SENDING: It violates of request-response and no concurrent rules");
}
mState = STATE_SENDING;
if (mState == STATE_SENDING) {
MOZ_CRASH(
"STATE_SENDING: It violates of request-response and no concurrent "
"rules");
}
mState = STATE_SENDING;
#endif
auto clean_fdset = MakeScopeExit([&] {
aMsg.file_descriptor_set()->CommitAll();
});
auto clean_fdset =
MakeScopeExit([&] { aMsg.file_descriptor_set()->CommitAll(); });
int num_fds = aMsg.file_descriptor_set()->size();
msghdr hdr;
InitMsgHdr(&hdr, kMaxIOVecSize, num_fds);
int num_fds = aMsg.file_descriptor_set()->size();
msghdr hdr;
InitMsgHdr(&hdr, kMaxIOVecSize, num_fds);
UniquePtr<msghdr, decltype(&DeinitMsgHdr)> uniq(&hdr, &DeinitMsgHdr);
UniquePtr<msghdr, decltype(&DeinitMsgHdr)> uniq(&hdr, &DeinitMsgHdr);
PrepareFDs(&hdr, aMsg);
DebugOnly<size_t> bytes_to_send = PrepareBuffers(&hdr, aMsg);
PrepareFDs(&hdr, aMsg);
DebugOnly<size_t> bytes_to_send = PrepareBuffers(&hdr, aMsg);
ssize_t bytes_written = HANDLE_EINTR(sendmsg(mFd, &hdr, 0));
ssize_t bytes_written = HANDLE_EINTR(sendmsg(mFd, &hdr, 0));
if (bytes_written < 0) {
char error[128];
SprintfLiteral(error, "sendmsg: %s", strerror(errno));
NS_WARNING(error);
return false;
}
MOZ_ASSERT(bytes_written == (ssize_t)bytes_to_send, "The message is too big?!");
if (bytes_written < 0) {
char error[128];
SprintfLiteral(error, "sendmsg: %s", strerror(errno));
NS_WARNING(error);
return false;
}
MOZ_ASSERT(bytes_written == (ssize_t)bytes_to_send,
"The message is too big?!");
return true;
return true;
}
unsigned
MiniTransceiver::RecvFDs(msghdr* aHdr, int* aAllFds, unsigned aMaxFds) {
if (aHdr->msg_controllen == 0) {
return 0;
}
unsigned MiniTransceiver::RecvFDs(msghdr* aHdr, int* aAllFds,
unsigned aMaxFds) {
if (aHdr->msg_controllen == 0) {
return 0;
}
unsigned num_all_fds = 0;
for (cmsghdr* cmsg = CMSG_FIRSTHDR(aHdr);
cmsg;
cmsg = CMSG_NXTHDR(aHdr, cmsg)) {
MOZ_ASSERT(cmsg->cmsg_level == SOL_SOCKET &&
cmsg->cmsg_type == SCM_RIGHTS,
"Accept only SCM_RIGHTS to receive file descriptors");
unsigned num_all_fds = 0;
for (cmsghdr* cmsg = CMSG_FIRSTHDR(aHdr); cmsg;
cmsg = CMSG_NXTHDR(aHdr, cmsg)) {
MOZ_ASSERT(cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS,
"Accept only SCM_RIGHTS to receive file descriptors");
unsigned payload_sz = cmsg->cmsg_len - CMSG_LEN(0);
MOZ_ASSERT(payload_sz % sizeof(int) == 0);
unsigned payload_sz = cmsg->cmsg_len - CMSG_LEN(0);
MOZ_ASSERT(payload_sz % sizeof(int) == 0);
// Add fds to |aAllFds|
unsigned num_part_fds = payload_sz / sizeof(int);
int* part_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
MOZ_ASSERT(num_all_fds + num_part_fds <= aMaxFds);
// Add fds to |aAllFds|
unsigned num_part_fds = payload_sz / sizeof(int);
int* part_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
MOZ_ASSERT(num_all_fds + num_part_fds <= aMaxFds);
memcpy(aAllFds + num_all_fds, part_fds, num_part_fds * sizeof(int));
num_all_fds += num_part_fds;
}
return num_all_fds;
memcpy(aAllFds + num_all_fds, part_fds, num_part_fds * sizeof(int));
num_all_fds += num_part_fds;
}
return num_all_fds;
}
bool
MiniTransceiver::RecvData(char* aDataBuf, size_t aBufSize, uint32_t* aMsgSize,
int* aFdsBuf, unsigned aMaxFds, unsigned* aNumFds) {
msghdr hdr;
InitMsgHdr(&hdr, 1, aMaxFds);
bool MiniTransceiver::RecvData(char* aDataBuf, size_t aBufSize,
uint32_t* aMsgSize, int* aFdsBuf,
unsigned aMaxFds, unsigned* aNumFds) {
msghdr hdr;
InitMsgHdr(&hdr, 1, aMaxFds);
UniquePtr<msghdr, decltype(&DeinitMsgHdr)> uniq(&hdr, &DeinitMsgHdr);
UniquePtr<msghdr, decltype(&DeinitMsgHdr)> uniq(&hdr, &DeinitMsgHdr);
// The buffer to collect all fds received from the socket.
int* all_fds = aFdsBuf;
unsigned num_all_fds = 0;
// The buffer to collect all fds received from the socket.
int* all_fds = aFdsBuf;
unsigned num_all_fds = 0;
size_t total_readed = 0;
uint32_t msgsz = 0;
while (msgsz == 0 || total_readed < msgsz) {
// Set IO vector with the begin of the unused buffer.
hdr.msg_iov->iov_base = aDataBuf + total_readed;
hdr.msg_iov->iov_len = (msgsz == 0 ? aBufSize : msgsz) - total_readed;
size_t total_readed = 0;
uint32_t msgsz = 0;
while (msgsz == 0 || total_readed < msgsz) {
// Set IO vector with the begin of the unused buffer.
hdr.msg_iov->iov_base = aDataBuf + total_readed;
hdr.msg_iov->iov_len = (msgsz == 0 ? aBufSize : msgsz) - total_readed;
// Read the socket
ssize_t bytes_readed = HANDLE_EINTR(recvmsg(mFd, &hdr, 0));
if (bytes_readed <= 0) {
// Closed or error!
return false;
}
total_readed += bytes_readed;
MOZ_ASSERT(total_readed <= aBufSize);
// Read the socket
ssize_t bytes_readed = HANDLE_EINTR(recvmsg(mFd, &hdr, 0));
if (bytes_readed <= 0) {
// Closed or error!
return false;
}
total_readed += bytes_readed;
MOZ_ASSERT(total_readed <= aBufSize);
if (msgsz == 0) {
// Parse the size of the message.
// Get 0 if data in the buffer is no enough to get message size.
msgsz = IPC::Message::MessageSize(aDataBuf, aDataBuf + total_readed);
}
num_all_fds += RecvFDs(&hdr, all_fds + num_all_fds, aMaxFds - num_all_fds);
if (msgsz == 0) {
// Parse the size of the message.
// Get 0 if data in the buffer is no enough to get message size.
msgsz = IPC::Message::MessageSize(aDataBuf, aDataBuf + total_readed);
}
*aMsgSize = msgsz;
*aNumFds = num_all_fds;
return true;
num_all_fds += RecvFDs(&hdr, all_fds + num_all_fds, aMaxFds - num_all_fds);
}
*aMsgSize = msgsz;
*aNumFds = num_all_fds;
return true;
}
bool
MiniTransceiver::Recv(IPC::Message& aMsg) {
bool MiniTransceiver::Recv(IPC::Message& aMsg) {
#ifdef DEBUG
if (mState == STATE_RECEIVING) {
MOZ_CRASH("STATE_RECEIVING: It violates of request-response and no concurrent rules");
}
mState = STATE_RECEIVING;
if (mState == STATE_RECEIVING) {
MOZ_CRASH(
"STATE_RECEIVING: It violates of request-response and no concurrent "
"rules");
}
mState = STATE_RECEIVING;
#endif
UniquePtr<char[]> databuf = MakeUnique<char[]>(kMaxDataSize);
uint32_t msgsz = 0;
int all_fds[kMaxNumFds];
unsigned num_all_fds = 0;
UniquePtr<char[]> databuf = MakeUnique<char[]>(kMaxDataSize);
uint32_t msgsz = 0;
int all_fds[kMaxNumFds];
unsigned num_all_fds = 0;
if (!RecvData(databuf.get(), kMaxDataSize, &msgsz,
all_fds, kMaxDataSize, &num_all_fds)) {
return false;
}
if (!RecvData(databuf.get(), kMaxDataSize, &msgsz, all_fds, kMaxDataSize,
&num_all_fds)) {
return false;
}
// Create Message from databuf & all_fds.
UniquePtr<IPC::Message> msg = MakeUnique<IPC::Message>(databuf.get(), msgsz);
msg->file_descriptor_set()->SetDescriptors(all_fds, num_all_fds);
// Create Message from databuf & all_fds.
UniquePtr<IPC::Message> msg = MakeUnique<IPC::Message>(databuf.get(), msgsz);
msg->file_descriptor_set()->SetDescriptors(all_fds, num_all_fds);
if (mDataBufClear == DataBufferClear::AfterReceiving) {
// Avoid content processes from reading the content of
// messages.
memset(databuf.get(), 0, msgsz);
}
if (mDataBufClear == DataBufferClear::AfterReceiving) {
// Avoid content processes from reading the content of
// messages.
memset(databuf.get(), 0, msgsz);
}
MOZ_ASSERT(msg->header()->num_fds == msg->file_descriptor_set()->size(),
"The number of file descriptors in the header is different from"
" the number actually received");
MOZ_ASSERT(msg->header()->num_fds == msg->file_descriptor_set()->size(),
"The number of file descriptors in the header is different from"
" the number actually received");
aMsg = std::move(*msg);
return true;
aMsg = std::move(*msg);
return true;
}

150
ipc/glue/MiniTransceiver.h
Просмотреть файл

@ -14,10 +14,7 @@ struct msghdr;
namespace mozilla {
namespace ipc {
enum class DataBufferClear {
None,
AfterReceiving
};
enum class DataBufferClear { None, AfterReceiving };
/**
* This simple implementation handles the transmissions of IPC
@ -31,89 +28,90 @@ enum class DataBufferClear {
* complexity of asynchronous I/O.
*/
class MiniTransceiver {
public:
/**
* \param aFd should be a blocking, no O_NONBLOCK, fd.
* \param aClearDataBuf is true to clear data buffers after
* receiving a message.
*/
explicit MiniTransceiver(int aFd, DataBufferClear aDataBufClear = DataBufferClear::None);
public:
/**
* \param aFd should be a blocking, no O_NONBLOCK, fd.
* \param aClearDataBuf is true to clear data buffers after
* receiving a message.
*/
explicit MiniTransceiver(
int aFd, DataBufferClear aDataBufClear = DataBufferClear::None);
bool Send(IPC::Message& aMsg);
inline bool SendInfallible(IPC::Message& aMsg, const char* aCrashMessage) {
bool Ok = Send(aMsg);
if (!Ok) {
MOZ_CRASH_UNSAFE(aCrashMessage);
}
return Ok;
bool Send(IPC::Message& aMsg);
inline bool SendInfallible(IPC::Message& aMsg, const char* aCrashMessage) {
bool Ok = Send(aMsg);
if (!Ok) {
MOZ_CRASH_UNSAFE(aCrashMessage);
}
return Ok;
}
/**
* \param aMsg will hold the content of the received message.
* \return false if the fd is closed or with an error.
*/
bool Recv(IPC::Message& aMsg);
inline bool RecvInfallible(IPC::Message& aMsg, const char* aCrashMessage) {
bool Ok = Recv(aMsg);
if (!Ok) {
MOZ_CRASH_UNSAFE(aCrashMessage);
}
return Ok;
/**
* \param aMsg will hold the content of the received message.
* \return false if the fd is closed or with an error.
*/
bool Recv(IPC::Message& aMsg);
inline bool RecvInfallible(IPC::Message& aMsg, const char* aCrashMessage) {
bool Ok = Recv(aMsg);
if (!Ok) {
MOZ_CRASH_UNSAFE(aCrashMessage);
}
return Ok;
}
int GetFD() { return mFd; }
int GetFD() { return mFd; }
private:
/**
* Set control buffer to make file descriptors ready to be sent
* through a socket.
*/
void PrepareFDs(msghdr* aHdr, IPC::Message& aMsg);
/**
* Collect buffers of the message and make them ready to be sent.
*
* \param aHdr is the structure going to be passed to sendmsg().
* \param aMsg is the Message to send.
*/
size_t PrepareBuffers(msghdr* aHdr, IPC::Message& aMsg);
/**
* Collect file descriptors received.
*
* \param aAllFds is where to store file descriptors.
* \param aMaxFds is how many file descriptors can be stored in aAllFds.
* \return the number of received file descriptors.
*/
unsigned RecvFDs(msghdr* aHdr, int* aAllFds, unsigned aMaxFds);
/**
* Received data from the socket.
*
* \param aDataBuf is where to store the data from the socket.
* \param aBufSize is the size of the buffer.
* \param aMsgSize returns how many bytes were readed from the socket.
* \param aFdsBuf is the buffer to return file desriptors received.
* \param aMaxFds is the number of file descriptors that can be held.
* \param aNumFds returns the number of file descriptors received.
* \return true if sucess, or false for error.
*/
bool RecvData(char* aDataBuf, size_t aBufSize, uint32_t* aMsgSize,
int* aFdsBuf, unsigned aMaxFds, unsigned* aNumFds);
private:
/**
* Set control buffer to make file descriptors ready to be sent
* through a socket.
*/
void PrepareFDs(msghdr* aHdr, IPC::Message& aMsg);
/**
* Collect buffers of the message and make them ready to be sent.
*
* \param aHdr is the structure going to be passed to sendmsg().
* \param aMsg is the Message to send.
*/
size_t PrepareBuffers(msghdr* aHdr, IPC::Message& aMsg);
/**
* Collect file descriptors received.
*
* \param aAllFds is where to store file descriptors.
* \param aMaxFds is how many file descriptors can be stored in aAllFds.
* \return the number of received file descriptors.
*/
unsigned RecvFDs(msghdr* aHdr, int* aAllFds, unsigned aMaxFds);
/**
* Received data from the socket.
*
* \param aDataBuf is where to store the data from the socket.
* \param aBufSize is the size of the buffer.
* \param aMsgSize returns how many bytes were readed from the socket.
* \param aFdsBuf is the buffer to return file desriptors received.
* \param aMaxFds is the number of file descriptors that can be held.
* \param aNumFds returns the number of file descriptors received.
* \return true if sucess, or false for error.
*/
bool RecvData(char* aDataBuf, size_t aBufSize, uint32_t* aMsgSize,
int* aFdsBuf, unsigned aMaxFds, unsigned* aNumFds);
int mFd; // The file descriptor of the socket for IPC.
int mFd; // The file descriptor of the socket for IPC.
#ifdef DEBUG
enum State {
STATE_NONE,
STATE_SENDING,
STATE_RECEIVING,
};
State mState;
enum State {
STATE_NONE,
STATE_SENDING,
STATE_RECEIVING,
};
State mState;
#endif
// Clear all received data in temp buffers to avoid data leaking.
DataBufferClear mDataBufClear;
// Clear all received data in temp buffers to avoid data leaking.
DataBufferClear mDataBufClear;
};
} // ipc
} // mozilla
} // namespace ipc
} // namespace mozilla
#endif // __MINITRANSCEIVER_H_
#endif // __MINITRANSCEIVER_H_

6
layout/base/nsLayoutUtils.cpp
Просмотреть файл

@ -1099,7 +1099,8 @@ static bool GetDisplayPortImpl(
result = GetDisplayPortFromRectData(aContent, rectData, aMultiplier);
} else if (isDisplayportSuppressed ||
nsLayoutUtils::ShouldDisableApzForElement(aContent)) {
DisplayPortMarginsPropertyData noMargins(ScreenMargin(), 1, /*painted=*/false);
DisplayPortMarginsPropertyData noMargins(ScreenMargin(), 1,
/*painted=*/false);
result = GetDisplayPortFromMarginsData(aContent, &noMargins, aMultiplier);
} else {
result = GetDisplayPortFromMarginsData(aContent, marginsData, aMultiplier);
@ -1143,8 +1144,7 @@ bool nsLayoutUtils::GetDisplayPort(
bool usingDisplayPort =
GetDisplayPortImpl(aContent, aResult, multiplier,
MaxSizeExceededBehaviour::Assert, aOutPainted);
if (aResult && usingDisplayPort &&
aRelativeTo == RelativeTo::ScrollFrame) {
if (aResult && usingDisplayPort && aRelativeTo == RelativeTo::ScrollFrame) {
TranslateFromScrollPortToScrollFrame(aContent, aResult);
}
return usingDisplayPort;

2
layout/forms/nsFieldSetFrame.cpp
Просмотреть файл

@ -915,7 +915,7 @@ void nsFieldSetFrame::EnsureChildContinuation(nsIFrame* aChild,
}
if (aStatus.IsOverflowIncomplete()) {
if (nsFrameList* eoc =
GetPropTableFrames(ExcessOverflowContainersProperty())) {
GetPropTableFrames(ExcessOverflowContainersProperty())) {
eoc->AppendFrames(nullptr, nifs);
} else {
SetPropTableFrames(new (PresShell()) nsFrameList(nifs),

6
layout/generic/nsImageFrame.cpp
Просмотреть файл

@ -485,8 +485,7 @@ bool nsImageFrame::UpdateIntrinsicSize() {
return mIntrinsicSize != oldIntrinsicSize;
}
static AspectRatio ComputeAspectRatio(imgIContainer* aImage,
bool aHasRequest,
static AspectRatio ComputeAspectRatio(imgIContainer* aImage, bool aHasRequest,
const nsImageFrame& aFrame) {
const ComputedStyle& style = *aFrame.Style();
if (style.StyleDisplay()->IsContainSize()) {
@ -718,8 +717,7 @@ void nsImageFrame::UpdateImage(imgIRequest* aRequest, imgIContainer* aImage) {
}
// NOTE(emilio): Intentionally using `|` instead of `||` to avoid
// short-circuiting.
bool intrinsicSizeChanged =
UpdateIntrinsicSize() | UpdateIntrinsicRatio();
bool intrinsicSizeChanged = UpdateIntrinsicSize() | UpdateIntrinsicRatio();
if (!GotInitialReflow()) {
return;
}

9
layout/mathml/nsMathMLContainerFrame.h
Просмотреть файл

@ -71,8 +71,7 @@ class nsMathMLContainerFrame : public nsContainerFrame, public nsMathMLFrame {
if (aFlags & (eLineParticipant | eSupportsContainLayoutAndPaint)) {
return false;
}
return nsContainerFrame::IsFrameOfType(
aFlags & ~eMathML);
return nsContainerFrame::IsFrameOfType(aFlags & ~eMathML);
}
virtual void AppendFrames(ChildListID aListID,
@ -419,8 +418,7 @@ class nsMathMLmathBlockFrame final : public nsBlockFrame {
}
virtual bool IsFrameOfType(uint32_t aFlags) const override {
return nsBlockFrame::IsFrameOfType(
aFlags & ~nsIFrame::eMathML);
return nsBlockFrame::IsFrameOfType(aFlags & ~nsIFrame::eMathML);
}
// See nsIMathMLFrame.h
@ -488,8 +486,7 @@ class nsMathMLmathInlineFrame final : public nsInlineFrame,
}
virtual bool IsFrameOfType(uint32_t aFlags) const override {
return nsInlineFrame::IsFrameOfType(
aFlags & ~nsIFrame::eMathML);
return nsInlineFrame::IsFrameOfType(aFlags & ~nsIFrame::eMathML);
}
bool IsMrowLike() override {

3
layout/mathml/nsMathMLmtableFrame.h
Просмотреть файл

@ -272,8 +272,7 @@ class nsMathMLmtdInnerFrame final : public nsBlockFrame, public nsMathMLFrame {
nsReflowStatus& aStatus) override;
virtual bool IsFrameOfType(uint32_t aFlags) const override {
return nsBlockFrame::IsFrameOfType(
aFlags & ~nsIFrame::eMathML);
return nsBlockFrame::IsFrameOfType(aFlags & ~nsIFrame::eMathML);
}
virtual const nsStyleText* StyleTextForLineLayout() override;

4
layout/xul/nsBoxFrame.h
Просмотреть файл

@ -116,8 +116,8 @@ class nsBoxFrame : public nsContainerFrame {
// that contains a block so ReflowInput doesn't tell us to be
// NS_UNCONSTRAINEDSIZE wide.)
return nsContainerFrame::IsFrameOfType(
aFlags & ~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock |
eXULBox));
aFlags &
~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock | eXULBox));
}
#ifdef DEBUG_FRAME_DUMP

18
media/webrtc/signaling/gtest/videoconduit_unittests.cpp
Просмотреть файл

@ -1407,7 +1407,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsNegotiatedThenSinkWants) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 960);
ASSERT_EQ(sink->mVideoFrame.height(), 540);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
wants.max_pixel_count = 3600 * 16 * 16;
@ -1416,7 +1416,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsNegotiatedThenSinkWants) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 960);
ASSERT_EQ(sink->mVideoFrame.height(), 540);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
mVideoConduit->StopTransmitting();
@ -1445,7 +1445,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsCodecChange) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 960);
ASSERT_EQ(sink->mVideoFrame.height(), 540);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
VideoCodecConfig codecConfigVP9(121, "VP9", constraints);
@ -1457,7 +1457,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsCodecChange) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 960);
ASSERT_EQ(sink->mVideoFrame.height(), 540);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
mVideoConduit->StopTransmitting();
@ -1486,7 +1486,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsSinkWantsThenCodecChange) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 960);
ASSERT_EQ(sink->mVideoFrame.height(), 540);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
VideoCodecConfig codecConfigVP9(121, "VP9", constraints);
@ -1497,7 +1497,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsSinkWantsThenCodecChange) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 960);
ASSERT_EQ(sink->mVideoFrame.height(), 540);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
mVideoConduit->StopTransmitting();
@ -1524,7 +1524,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsNegotiated) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 1280);
ASSERT_EQ(sink->mVideoFrame.height(), 720);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
// Ensure that negotiating a new max-fs works
@ -1535,7 +1535,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsNegotiated) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 960);
ASSERT_EQ(sink->mVideoFrame.height(), 540);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
// Ensure that negotiating max-fs away works
@ -1546,7 +1546,7 @@ TEST_F(VideoConduitTest, TestVideoEncodeMaxFsNegotiated) {
SendVideoFrame(1280, 720, frame++);
ASSERT_EQ(sink->mVideoFrame.width(), 1280);
ASSERT_EQ(sink->mVideoFrame.height(), 720);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame-1)*1000);
ASSERT_EQ(sink->mVideoFrame.timestamp_us(), (frame - 1) * 1000);
ASSERT_EQ(sink->mOnFrameCount, frame);
mVideoConduit->StopTransmitting();

5
media/webrtc/signaling/src/media-conduit/VideoConduit.h
Просмотреть файл

@ -208,8 +208,9 @@ class WebrtcVideoConduit
*/
void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
const rtc::VideoSinkWants& wants) override;
void AddOrUpdateSinkNotLocked(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
const rtc::VideoSinkWants& wants);
void AddOrUpdateSinkNotLocked(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
const rtc::VideoSinkWants& wants);
void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
void RemoveSinkNotLocked(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink);

23
media/webrtc/signaling/src/peerconnection/RTCStatsIdGenerator.h
Просмотреть файл

@ -12,18 +12,19 @@
namespace mozilla {
class RTCStatsIdGenerator {
public:
RTCStatsIdGenerator();
nsString Id(const nsString& aKey);
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RTCStatsIdGenerator);
private:
virtual ~RTCStatsIdGenerator() {};
nsString Generate();
public:
RTCStatsIdGenerator();
nsString Id(const nsString& aKey);
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RTCStatsIdGenerator);
const uint64_t mSalt;
uint64_t mCounter;
std::map<nsString, nsString> mAllocated;
private:
virtual ~RTCStatsIdGenerator(){};
nsString Generate();
const uint64_t mSalt;
uint64_t mCounter;
std::map<nsString, nsString> mAllocated;
};
}
} // namespace mozilla
#endif

2
mfbt/RangedPtr.h
Просмотреть файл

@ -120,7 +120,7 @@ class RangedPtr {
}
MOZ_IMPLICIT RangedPtr(const RangedPtr<T>& aOther)
: mPtr(aOther.mPtr)
: mPtr(aOther.mPtr)
#ifdef DEBUG
,
mRangeStart(aOther.mRangeStart),

4
mozglue/misc/NativeNt.h
Просмотреть файл

@ -241,9 +241,7 @@ struct MemorySectionNameBuf : public _MEMORY_SECTION_NAME {
mSectionFileName.Buffer = mBuf;
}
MemorySectionNameBuf(const MemorySectionNameBuf& aOther) {
*this = aOther;
}
MemorySectionNameBuf(const MemorySectionNameBuf& aOther) { *this = aOther; }
MemorySectionNameBuf(MemorySectionNameBuf&& aOther) {
*this = std::move(aOther);

2
netwerk/protocol/websocket/WebSocketChannel.cpp
Просмотреть файл

@ -1075,7 +1075,7 @@ class OutboundMessage {
class OutboundEnqueuer final : public Runnable {
public:
OutboundEnqueuer(WebSocketChannel* aChannel, OutboundMessage* aMsg)
: Runnable("OutboundEnquerer"), mChannel(aChannel), mMessage(aMsg) {}
: Runnable("OutboundEnquerer"), mChannel(aChannel), mMessage(aMsg) {}
NS_IMETHOD Run() override {
mChannel->EnqueueOutgoingMessage(mChannel->mOutgoingMessages, mMessage);

4
netwerk/system/android/nsAndroidNetworkLinkService.cpp
Просмотреть файл

@ -204,8 +204,8 @@ void nsAndroidNetworkLinkService::OnLinkStatusKnown() { mStatusIsKnown = true; }
void nsAndroidNetworkLinkService::OnDnsSuffixListUpdated() {
RefPtr<nsAndroidNetworkLinkService> self = this;
NS_DispatchToMainThread(
NS_NewRunnableFunction("nsAndroidNetworkLinkService::OnDnsSuffixListUpdated", [self]() {
NS_DispatchToMainThread(NS_NewRunnableFunction(
"nsAndroidNetworkLinkService::OnDnsSuffixListUpdated", [self]() {
self->NotifyObservers(NS_DNS_SUFFIX_LIST_UPDATED_TOPIC, nullptr);
}));
}

4
netwerk/system/linux/nsNetworkLinkService.cpp
Просмотреть файл

@ -169,8 +169,8 @@ void nsNetworkLinkService::OnLinkStatusKnown() { mStatusIsKnown = true; }
void nsNetworkLinkService::OnDnsSuffixListUpdated() {
RefPtr<nsNetworkLinkService> self = this;
NS_DispatchToMainThread(
NS_NewRunnableFunction("nsNetworkLinkService::OnDnsSuffixListUpdated", [self]() {
NS_DispatchToMainThread(NS_NewRunnableFunction(
"nsNetworkLinkService::OnDnsSuffixListUpdated", [self]() {
self->NotifyObservers(NS_DNS_SUFFIX_LIST_UPDATED_TOPIC, nullptr);
}));
}

5
netwerk/test/fuzz/TestHttpFuzzing.cpp
Просмотреть файл

@ -221,9 +221,8 @@ static int FuzzingRunNetworkHttp(const uint8_t* data, size_t size) {
bool mainPingBack = false;
NS_DispatchBackgroundTask(NS_NewRunnableFunction("Dummy", [&]() {
NS_DispatchToMainThread(NS_NewRunnableFunction("Dummy", [&]() {
mainPingBack = true;
}));
NS_DispatchToMainThread(
NS_NewRunnableFunction("Dummy", [&]() { mainPingBack = true; }));
}));
SpinEventLoopUntil([&]() -> bool { return mainPingBack; });

21
security/sandbox/linux/launch/SandboxLaunch.cpp
Просмотреть файл

@ -209,8 +209,7 @@ static void AttachSandboxReporter(base::file_handle_mapping_vector* aFdMap) {
class SandboxFork : public base::LaunchOptions::ForkDelegate {
public:
explicit SandboxFork(int aFlags, bool aChroot,
int aServerFd = -1,
explicit SandboxFork(int aFlags, bool aChroot, int aServerFd = -1,
int aClientFd = -1);
virtual ~SandboxFork();
@ -335,7 +334,7 @@ void SandboxLaunchPrepare(GeckoProcessType aType,
aOptions->fork_delegate = std::move(forker);
// Pass to |SandboxLaunchForkServerPrepare()| in the fork server.
aOptions->env_map[kSandboxChrootEnvFlag] =
std::to_string(canChroot ? 1 : 0) + std::to_string(flags);
std::to_string(canChroot ? 1 : 0) + std::to_string(flags);
}
}
@ -349,11 +348,9 @@ void SandboxLaunchPrepare(GeckoProcessType aType,
*/
void SandboxLaunchForkServerPrepare(const std::vector<std::string>& aArgv,
base::LaunchOptions& aOptions) {
auto chroot = std::find_if(aOptions.env_map.begin(),
aOptions.env_map.end(),
[](auto& elt) {
return elt.first == kSandboxChrootEnvFlag;
});
auto chroot = std::find_if(
aOptions.env_map.begin(), aOptions.env_map.end(),
[](auto& elt) { return elt.first == kSandboxChrootEnvFlag; });
if (chroot == aOptions.env_map.end()) {
return;
}
@ -363,11 +360,9 @@ void SandboxLaunchForkServerPrepare(const std::vector<std::string>& aArgv,
// Find chroot server fd. It is supposed to be map to
// kSandboxChrootServerFd so that we find it out from the mapping.
auto fdmap = std::find_if(aOptions.fds_to_remap.begin(),
aOptions.fds_to_remap.end(),
[](auto& elt) {
return elt.second == kSandboxChrootServerFd;
});
auto fdmap = std::find_if(
aOptions.fds_to_remap.begin(), aOptions.fds_to_remap.end(),
[](auto& elt) { return elt.second == kSandboxChrootServerFd; });
MOZ_ASSERT(fdmap != aOptions.fds_to_remap.end(),
"ChrootServerFd is not found with sandbox chroot");
int chrootserverfd = fdmap->first;

3
toolkit/xre/nsEmbedFunctions.cpp
Просмотреть файл

@ -267,8 +267,7 @@ void XRE_SetAndroidChildFds(JNIEnv* env, const XRE_AndroidChildFds& fds) {
void XRE_SetProcessType(const char* aProcessTypeString) {
static bool called = false;
if (called &&
sChildProcessType != GeckoProcessType_ForkServer) {
if (called && sChildProcessType != GeckoProcessType_ForkServer) {
MOZ_CRASH();
}
called = true;

79
widget/windows/ToastNotificationHandler.cpp
Просмотреть файл

@ -29,15 +29,15 @@ namespace mozilla {
namespace widget {
typedef ABI::Windows::Foundation::ITypedEventHandler<
ABI::Windows::UI::Notifications::ToastNotification *, IInspectable *>
ABI::Windows::UI::Notifications::ToastNotification*, IInspectable*>
ToastActivationHandler;
typedef ABI::Windows::Foundation::ITypedEventHandler<
ABI::Windows::UI::Notifications::ToastNotification *,
ABI::Windows::UI::Notifications::ToastDismissedEventArgs *>
ABI::Windows::UI::Notifications::ToastNotification*,
ABI::Windows::UI::Notifications::ToastDismissedEventArgs*>
ToastDismissedHandler;
typedef ABI::Windows::Foundation::ITypedEventHandler<
ABI::Windows::UI::Notifications::ToastNotification *,
ABI::Windows::UI::Notifications::ToastFailedEventArgs *>
ABI::Windows::UI::Notifications::ToastNotification*,
ABI::Windows::UI::Notifications::ToastFailedEventArgs*>
ToastFailedHandler;
using namespace ABI::Windows::Data::Xml::Dom;
@ -49,11 +49,11 @@ using namespace mozilla;
NS_IMPL_ISUPPORTS(ToastNotificationHandler, nsIAlertNotificationImageListener)
static bool SetNodeValueString(const nsString &aString, IXmlNode *node,
IXmlDocument *xml) {
static bool SetNodeValueString(const nsString& aString, IXmlNode* node,
IXmlDocument* xml) {
ComPtr<IXmlText> inputText;
if (NS_WARN_IF(FAILED(xml->CreateTextNode(
HStringReference(static_cast<const wchar_t *>(aString.get())).Get(),
HStringReference(static_cast<const wchar_t*>(aString.get())).Get(),
&inputText)))) {
return false;
}
@ -69,9 +69,9 @@ static bool SetNodeValueString(const nsString &aString, IXmlNode *node,
return true;
}
static bool SetAttribute(IXmlElement *element, const HSTRING name,
const nsAString &value) {
HSTRING valueStr = HStringReference(static_cast<const wchar_t *>(
static bool SetAttribute(IXmlElement* element, const HSTRING name,
const nsAString& value) {
HSTRING valueStr = HStringReference(static_cast<const wchar_t*>(
PromiseFlatString(value).get()))
.Get();
if (NS_WARN_IF(FAILED(element->SetAttribute(name, valueStr)))) {
@ -80,9 +80,9 @@ static bool SetAttribute(IXmlElement *element, const HSTRING name,
return true;
}
static bool AddActionNode(IXmlDocument *toastXml, IXmlNode *actionsNode,
const nsAString &actionTitle,
const nsAString &actionArgs) {
static bool AddActionNode(IXmlDocument* toastXml, IXmlNode* actionsNode,
const nsAString& actionTitle,
const nsAString& actionArgs) {
ComPtr<IXmlElement> action;
HRESULT hr =
toastXml->CreateElement(HStringReference(L"action").Get(), &action);
@ -174,8 +174,8 @@ ComPtr<IXmlDocument> ToastNotificationHandler::InitializeXmlForTemplate(
return toastXml;
}
nsresult
ToastNotificationHandler::InitAlertAsync(nsIAlertNotification *aAlert) {
nsresult ToastNotificationHandler::InitAlertAsync(
nsIAlertNotification* aAlert) {
return aAlert->LoadImage(/* aTimeout = */ 0, this, /* aUserData = */ nullptr,
getter_AddRefs(mImageRequest));
}
@ -341,7 +341,7 @@ bool ToastNotificationHandler::ShowAlert() {
}
bool ToastNotificationHandler::CreateWindowsNotificationFromXml(
IXmlDocument *aXml) {
IXmlDocument* aXml) {
ComPtr<IToastNotificationFactory> factory;
HRESULT hr = GetActivationFactory(
HStringReference(RuntimeClass_Windows_UI_Notifications_ToastNotification)
@ -359,8 +359,8 @@ bool ToastNotificationHandler::CreateWindowsNotificationFromXml(
RefPtr<ToastNotificationHandler> self = this;
hr = mNotification->add_Activated(
Callback<ToastActivationHandler>([self](IToastNotification *aNotification,
IInspectable *aInspectable) {
Callback<ToastActivationHandler>([self](IToastNotification* aNotification,
IInspectable* aInspectable) {
return self->OnActivate(aNotification, aInspectable);
}).Get(),
&mActivatedToken);
@ -369,8 +369,8 @@ bool ToastNotificationHandler::CreateWindowsNotificationFromXml(
}
hr = mNotification->add_Dismissed(
Callback<ToastDismissedHandler>([self](IToastNotification *aNotification,
IToastDismissedEventArgs *aArgs) {
Callback<ToastDismissedHandler>([self](IToastNotification* aNotification,
IToastDismissedEventArgs* aArgs) {
return self->OnDismiss(aNotification, aArgs);
}).Get(),
&mDismissedToken);
@ -379,8 +379,8 @@ bool ToastNotificationHandler::CreateWindowsNotificationFromXml(
}
hr = mNotification->add_Failed(
Callback<ToastFailedHandler>([self](IToastNotification *aNotification,
IToastFailedEventArgs *aArgs) {
Callback<ToastFailedHandler>([self](IToastNotification* aNotification,
IToastFailedEventArgs* aArgs) {
return self->OnFail(aNotification, aArgs);
}).Get(),
&mFailedToken);
@ -400,7 +400,7 @@ bool ToastNotificationHandler::CreateWindowsNotificationFromXml(
}
HSTRING uidStr =
HStringReference(static_cast<const wchar_t *>(uid.get())).Get();
HStringReference(static_cast<const wchar_t*>(uid.get())).Get();
hr = toastNotificationManagerStatics->CreateToastNotifierWithId(uidStr,
&mNotifier);
if (NS_WARN_IF(FAILED(hr))) {
@ -419,8 +419,7 @@ bool ToastNotificationHandler::CreateWindowsNotificationFromXml(
return true;
}
void
ToastNotificationHandler::SendFinished() {
void ToastNotificationHandler::SendFinished() {
if (!mSentFinished && mAlertListener) {
mAlertListener->Observe(nullptr, "alertfinished", mCookie.get());
}
@ -429,20 +428,20 @@ ToastNotificationHandler::SendFinished() {
}
HRESULT
ToastNotificationHandler::OnActivate(IToastNotification *notification,
IInspectable *inspectable) {
ToastNotificationHandler::OnActivate(IToastNotification* notification,
IInspectable* inspectable) {
if (mAlertListener) {
nsAutoString argString;
if (inspectable) {
ComPtr<IToastActivatedEventArgs> eventArgs;
HRESULT hr = inspectable->QueryInterface(
__uuidof(IToastActivatedEventArgs), (void **)&eventArgs);
__uuidof(IToastActivatedEventArgs), (void**)&eventArgs);
if (SUCCEEDED(hr)) {
HSTRING arguments;
hr = eventArgs->get_Arguments(&arguments);
if (SUCCEEDED(hr)) {
uint32_t len = 0;
const wchar_t *buffer = WindowsGetStringRawBuffer(arguments, &len);
const wchar_t* buffer = WindowsGetStringRawBuffer(arguments, &len);
if (buffer) {
argString.Assign(buffer, len);
}
@ -480,16 +479,16 @@ ToastNotificationHandler::OnActivate(IToastNotification *notification,
}
HRESULT
ToastNotificationHandler::OnDismiss(IToastNotification *notification,
IToastDismissedEventArgs *aArgs) {
ToastNotificationHandler::OnDismiss(IToastNotification* notification,
IToastDismissedEventArgs* aArgs) {
SendFinished();
mBackend->RemoveHandler(mName, this);
return S_OK;
}
HRESULT
ToastNotificationHandler::OnFail(IToastNotification *notification,
IToastFailedEventArgs *aArgs) {
ToastNotificationHandler::OnFail(IToastNotification* notification,
IToastFailedEventArgs* aArgs) {
SendFinished();
mBackend->RemoveHandler(mName, this);
return S_OK;
@ -504,12 +503,12 @@ nsresult ToastNotificationHandler::TryShowAlert() {
}
NS_IMETHODIMP
ToastNotificationHandler::OnImageMissing(nsISupports *) {
ToastNotificationHandler::OnImageMissing(nsISupports*) {
return TryShowAlert();
}
NS_IMETHODIMP
ToastNotificationHandler::OnImageReady(nsISupports *, imgIRequest *aRequest) {
ToastNotificationHandler::OnImageReady(nsISupports*, imgIRequest* aRequest) {
nsresult rv = AsyncSaveImage(aRequest);
if (NS_FAILED(rv)) {
return TryShowAlert();
@ -517,7 +516,7 @@ ToastNotificationHandler::OnImageReady(nsISupports *, imgIRequest *aRequest) {
return rv;
}
nsresult ToastNotificationHandler::AsyncSaveImage(imgIRequest *aRequest) {
nsresult ToastNotificationHandler::AsyncSaveImage(imgIRequest* aRequest) {
nsresult rv =
NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(mImageFile));
if (NS_WARN_IF(NS_FAILED(rv))) {
@ -580,7 +579,7 @@ nsresult ToastNotificationHandler::AsyncSaveImage(imgIRequest *aRequest) {
nsCOMPtr<nsIRunnable> cbRunnable = NS_NewRunnableFunction(
"ToastNotificationHandler::AsyncWriteBitmapCb",
[self, rv]() -> void {
auto handler = const_cast<ToastNotificationHandler *>(self.get());
auto handler = const_cast<ToastNotificationHandler*>(self.get());
handler->OnWriteBitmapFinished(rv);
});
@ -619,5 +618,5 @@ nsresult ToastNotificationHandler::OnWriteBitmapSuccess() {
return NS_OK;
}
} // namespace widget
} // namespace mozilla
} // namespace widget
} // namespace mozilla

11
xpcom/base/nsTraceRefcnt.cpp
Просмотреть файл

@ -569,10 +569,11 @@ static void DoInitTraceLog(const char* aProcType) {
return;
}
bool defined =
InitLog(ENVVAR("XPCOM_MEM_BLOAT_LOG"), "bloat/leaks", &gBloatLog, aProcType);
bool defined = InitLog(ENVVAR("XPCOM_MEM_BLOAT_LOG"), "bloat/leaks",
&gBloatLog, aProcType);
if (!defined) {
gLogLeaksOnly = InitLog(ENVVAR("XPCOM_MEM_LEAK_LOG"), "leaks", &gBloatLog, aProcType);
gLogLeaksOnly =
InitLog(ENVVAR("XPCOM_MEM_LEAK_LOG"), "leaks", &gBloatLog, aProcType);
}
if (defined || gLogLeaksOnly) {
// Use the same bloat view, if there is, to keep it consistent
@ -1182,9 +1183,7 @@ static void ClearLogs(bool aKeepCounters) {
maybeUnregisterAndCloseFile(gCOMPtrLog);
}
void nsTraceRefcnt::Shutdown() {
ClearLogs(false);
}
void nsTraceRefcnt::Shutdown() { ClearLogs(false); }
void nsTraceRefcnt::SetActivityIsLegal(bool aLegal) {
if (gActivityTLS == BAD_TLS_INDEX) {

2
xpcom/build/nsXULAppAPI.h
Просмотреть файл

@ -513,6 +513,6 @@ XRE_API(void, XRE_LibFuzzerSetDriver, (LibFuzzerDriver))
XRE_API(int, XRE_ForkServer, (int* aArgc, char*** aArgv))
#endif // MOZ_ENABLE_FORKSERVER
#endif // MOZ_ENABLE_FORKSERVER
#endif // _nsXULAppAPI_h__

3
xpcom/threads/nsThreadManager.h
Просмотреть файл

@ -58,7 +58,8 @@ class nsThreadManager : public nsIThreadManager {
nsresult DispatchToBackgroundThread(nsIRunnable* aEvent,
uint32_t aDispatchFlags);
already_AddRefed<nsISerialEventTarget> CreateBackgroundTaskQueue(const char* aName);
already_AddRefed<nsISerialEventTarget> CreateBackgroundTaskQueue(
const char* aName);
// Returns the maximal number of threads that have been in existence
// simultaneously during the execution of the thread manager.

2
xpcom/threads/nsThreadUtils.cpp
Просмотреть файл

@ -534,7 +534,7 @@ nsresult NS_DispatchBackgroundTask(nsIRunnable* aEvent,
nsresult NS_CreateBackgroundTaskQueue(const char* aName,
nsISerialEventTarget** aTarget) {
nsCOMPtr<nsISerialEventTarget> target =
nsThreadManager::get().CreateBackgroundTaskQueue(aName);
nsThreadManager::get().CreateBackgroundTaskQueue(aName);
if (!target) {
return NS_ERROR_FAILURE;
}