nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

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

Browse source 
# 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
parent 4a2545c164
commit c521758c5e
52 changed files with 793 additions and 843 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

2
accessible/base/nsAccessibilityService.h
View file

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

7
caps/ContentPrincipal.h
View file

@ -57,7 +57,12 @@ class ContentPrincipal final : public BasePrincipal {
virtual nsresult PopulateJSONObject(Json::Value& aObject) override; virtual nsresult PopulateJSONObject(Json::Value& aObject) override;
// Serializable keys are the valid enum fields the serialization supports // 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; typedef mozilla::BasePrincipal::KeyValT<SerializableKeys> KeyVal;
static already_AddRefed<BasePrincipal> FromProperties( static already_AddRefed<BasePrincipal> FromProperties(

1
docshell/shistory/ChildSHistory.h
View file

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

6
dom/bindings/BindingDeclarations.h
View file

@ -412,8 +412,10 @@ template <typename T>
class Sequence : public FallibleTArray<T> { class Sequence : public FallibleTArray<T> {
public: public:
Sequence() : FallibleTArray<T>() {} Sequence() : FallibleTArray<T>() {}
MOZ_IMPLICIT Sequence(FallibleTArray<T>&& aArray) : FallibleTArray<T>(std::move(aArray)) {} MOZ_IMPLICIT Sequence(FallibleTArray<T>&& aArray)
MOZ_IMPLICIT Sequence(nsTArray<T>&& aArray) : FallibleTArray<T>(std::move(aArray)) {} : FallibleTArray<T>(std::move(aArray)) {}
MOZ_IMPLICIT Sequence(nsTArray<T>&& aArray)
: FallibleTArray<T>(std::move(aArray)) {}
}; };
inline nsWrapperCache* GetWrapperCache(nsWrapperCache* cache) { return cache; } inline nsWrapperCache* GetWrapperCache(nsWrapperCache* cache) { return cache; }

3
dom/bindings/test/WrapperCachedNonISupportsTestInterface.h
View file

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

4
dom/localstorage/LSSnapshot.h
View file

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

3
dom/localstorage/LSValue.h
View file

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

16
dom/media/FileBlockCache.cpp
View file

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

11
dom/media/hls/HLSDemuxer.cpp
View file

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

3
dom/security/nsContentSecurityUtils.h
View file

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

3
gfx/2d/ScaleFactors2D.h
View file

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

3
image/imgTools.cpp
View file

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

7
ipc/app/MozillaRuntimeMain.cpp
View file

@ -13,8 +13,7 @@
using namespace mozilla; using namespace mozilla;
static bool static bool UseForkServer(int argc, char* argv[]) {
UseForkServer(int argc, char* argv[]) {
#if defined(MOZ_ENABLE_FORKSERVER) #if defined(MOZ_ENABLE_FORKSERVER)
return strcmp(argv[argc - 1], "forkserver") == 0; return strcmp(argv[argc - 1], "forkserver") == 0;
#else #else
@ -22,8 +21,8 @@ UseForkServer(int argc, char* argv[]) {
#endif #endif
} }
static int static int RunForkServer(Bootstrap::UniquePtr&& bootstrap, int argc,
RunForkServer(Bootstrap::UniquePtr&& bootstrap, int argc, char* argv[]) { char* argv[]) {
#if defined(MOZ_ENABLE_FORKSERVER) #if defined(MOZ_ENABLE_FORKSERVER)
int ret = 0; int ret = 0;

2
ipc/chromium/src/base/process_util.h
View file

@ -52,7 +52,7 @@ namespace mozilla {
namespace ipc { namespace ipc {
class FileDescriptor; class FileDescriptor;
} }
} } // namespace mozilla
#endif #endif
#if defined(OS_MACOSX) #if defined(OS_MACOSX)

51
ipc/chromium/src/base/process_util_linux.cc
View file

@ -51,16 +51,14 @@ namespace base {
#if defined(MOZ_ENABLE_FORKSERVER) #if defined(MOZ_ENABLE_FORKSERVER)
static mozilla::StaticAutoPtr<std::vector<int> > sNoCloseFDs; static mozilla::StaticAutoPtr<std::vector<int> > sNoCloseFDs;
void void RegisterForkServerNoCloseFD(int fd) {
RegisterForkServerNoCloseFD(int fd) {
if (!sNoCloseFDs) { if (!sNoCloseFDs) {
sNoCloseFDs = new std::vector<int>(); sNoCloseFDs = new std::vector<int>();
} }
sNoCloseFDs->push_back(fd); sNoCloseFDs->push_back(fd);
} }
static bool static bool IsNoCloseFd(int fd) {
IsNoCloseFd(int fd) {
if (!sNoCloseFDs) { if (!sNoCloseFDs) {
return false; return false;
} }
@ -68,19 +66,17 @@ IsNoCloseFd(int fd) {
[fd](int regfd) -> bool { return regfd == fd; }); [fd](int regfd) -> bool { return regfd == fd; });
} }
AppProcessBuilder::AppProcessBuilder() { AppProcessBuilder::AppProcessBuilder() {}
}
static void static void ReplaceEnviroment(const LaunchOptions& options) {
ReplaceEnviroment(const LaunchOptions& options) {
for (auto& elt : options.env_map) { for (auto& elt : options.env_map) {
setenv(elt.first.c_str(), elt.second.c_str(), 1); setenv(elt.first.c_str(), elt.second.c_str(), 1);
} }
} }
bool bool AppProcessBuilder::ForkProcess(const std::vector<std::string>& argv,
AppProcessBuilder::ForkProcess(const std::vector<std::string>& argv, const LaunchOptions& options,
const LaunchOptions& options, ProcessHandle* process_handle) { ProcessHandle* process_handle) {
auto cleanFDs = mozilla::MakeScopeExit([&] { auto cleanFDs = mozilla::MakeScopeExit([&] {
for (auto& elt : options.fds_to_remap) { for (auto& elt : options.fds_to_remap) {
auto fd = std::get<0>(elt); auto fd = std::get<0>(elt);
@ -127,8 +123,7 @@ AppProcessBuilder::ForkProcess(const std::vector<std::string>& argv,
return true; return true;
} }
void void AppProcessBuilder::ReplaceArguments(int* argcp, char*** argvp) {
AppProcessBuilder::ReplaceArguments(int *argcp, char*** argvp) {
// Change argc & argv of main() with the arguments passing // Change argc & argv of main() with the arguments passing
// through IPC. // through IPC.
char** argv = new char*[argv_.size() + 1]; char** argv = new char*[argv_.size() + 1];
@ -141,8 +136,7 @@ AppProcessBuilder::ReplaceArguments(int *argcp, char*** argvp) {
*argcp = argv_.size(); *argcp = argv_.size();
} }
void void AppProcessBuilder::InitAppProcess(int* argcp, char*** argvp) {
AppProcessBuilder::InitAppProcess(int *argcp, char*** argvp) {
MOZ_ASSERT(MessageLoop::current() == nullptr, MOZ_ASSERT(MessageLoop::current() == nullptr,
"The message loop of the main thread should have been destroyed"); "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) { CloseSuperfluousFds(&shuffle_, [](void* ctx, int fd) {
return static_cast<decltype(&shuffle_)>(ctx)->MapsTo(fd) || return static_cast<decltype(&shuffle_)>(ctx)->MapsTo(fd) || IsNoCloseFd(fd);
IsNoCloseFd(fd);
}); });
// Without this, the destructor of |shuffle_| would try to close FDs // Without this, the destructor of |shuffle_| would try to close FDs
// created by it, but they have been closed by // created by it, but they have been closed by
@ -168,21 +161,16 @@ AppProcessBuilder::InitAppProcess(int *argcp, char*** argvp) {
ReplaceArguments(argcp, argvp); ReplaceArguments(argcp, argvp);
} }
static void static void handle_sigchld(int s) { waitpid(-1, nullptr, WNOHANG); }
handle_sigchld(int s) {
waitpid(-1, nullptr, WNOHANG);
}
static void static void InstallChildSignalHandler() {
InstallChildSignalHandler() {
// Since content processes are not children of the chrome process // Since content processes are not children of the chrome process
// any more, the fork server process has to handle SIGCHLD, or // any more, the fork server process has to handle SIGCHLD, or
// content process would remain zombie after dead. // content process would remain zombie after dead.
signal(SIGCHLD, handle_sigchld); signal(SIGCHLD, handle_sigchld);
} }
static void static void ReserveFileDescriptors() {
ReserveFileDescriptors() {
// Reserve the lower positions of the file descriptors to make sure // Reserve the lower positions of the file descriptors to make sure
// debug files and other files don't take these positions. So we // debug files and other files don't take these positions. So we
// can keep their file descriptors during CloseSuperfluousFds() with // can keep their file descriptors during CloseSuperfluousFds() with
@ -193,14 +181,12 @@ ReserveFileDescriptors() {
} }
} }
void void InitForkServerProcess() {
InitForkServerProcess() {
InstallChildSignalHandler(); InstallChildSignalHandler();
ReserveFileDescriptors(); ReserveFileDescriptors();
} }
static bool static bool LaunchAppWithForkServer(const std::vector<std::string>& argv,
LaunchAppWithForkServer(const std::vector<std::string>& argv,
const LaunchOptions& options, const LaunchOptions& options,
ProcessHandle* process_handle) { ProcessHandle* process_handle) {
MOZ_ASSERT(ForkServiceChild::Get()); MOZ_ASSERT(ForkServiceChild::Get());
@ -217,12 +203,11 @@ LaunchAppWithForkServer(const std::vector<std::string>& argv,
nsCString(vv.second.c_str()))); nsCString(vv.second.c_str())));
} }
for (auto& fdmapping : options.fds_to_remap) { for (auto& fdmapping : options.fds_to_remap) {
fdsremap.AppendElement(mozilla::FdMapping(mozilla::ipc::FileDescriptor(fdmapping.first), fdsremap.AppendElement(mozilla::FdMapping(
fdmapping.second)); mozilla::ipc::FileDescriptor(fdmapping.first), fdmapping.second));
} }
return ForkServiceChild::Get()->SendForkNewSubprocess(_argv, env, return ForkServiceChild::Get()->SendForkNewSubprocess(_argv, env, fdsremap,
fdsremap,
process_handle); process_handle);
} }
#endif // MOZ_ENABLE_FORKSERVER #endif // MOZ_ENABLE_FORKSERVER

2
ipc/chromium/src/chrome/common/ipc_message.h
View file

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

4
ipc/glue/FileDescriptorShuffle.h
View file

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

65
ipc/glue/ForkServer.cpp
View file

@ -19,7 +19,6 @@
#include <algorithm> #include <algorithm>
namespace mozilla { namespace mozilla {
namespace ipc { namespace ipc {
@ -27,14 +26,12 @@ static const int sClientFd = 3;
LazyLogModule gForkServiceLog("ForkService"); LazyLogModule gForkServiceLog("ForkService");
ForkServer::ForkServer() { ForkServer::ForkServer() {}
}
/** /**
* Prepare an environment for running a fork server. * Prepare an environment for running a fork server.
*/ */
void void ForkServer::InitProcess(int* aArgc, char*** aArgv) {
ForkServer::InitProcess(int* aArgc, char*** aArgv) {
base::InitForkServerProcess(); base::InitForkServerProcess();
int fd = sClientFd; int fd = sClientFd;
@ -46,13 +43,12 @@ ForkServer::InitProcess(int* aArgc, char*** aArgv) {
/** /**
* Start providing the service at the IPC channel. * Start providing the service at the IPC channel.
*/ */
bool bool ForkServer::HandleMessages() {
ForkServer::HandleMessages() {
// |sClientFd| is created by an instance of |IPC::Channel|. // |sClientFd| is created by an instance of |IPC::Channel|.
// It sends a HELLO automatically. // It sends a HELLO automatically.
IPC::Message hello; IPC::Message hello;
mTcver->RecvInfallible(hello, mTcver->RecvInfallible(
"Expect to receive a HELLO message from the parent process!"); hello, "Expect to receive a HELLO message from the parent process!");
MOZ_ASSERT(hello.type() == kHELLO_MESSAGE_TYPE); MOZ_ASSERT(hello.type() == kHELLO_MESSAGE_TYPE);
// Send it back // Send it back
@ -75,16 +71,14 @@ ForkServer::HandleMessages() {
return true; return true;
} }
inline void inline void CleanCString(nsCString& str) {
CleanCString(nsCString& str) {
char* data; char* data;
int sz = str.GetMutableData(&data); int sz = str.GetMutableData(&data);
memset(data, ' ', sz); memset(data, ' ', sz);
} }
inline void inline void CleanString(std::string& str) {
CleanString(std::string& str) {
const char deadbeef[] = 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"
"\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,8 +92,7 @@ CleanString(std::string& str) {
} }
} }
inline void inline void PrepareArguments(std::vector<std::string>& aArgv,
PrepareArguments(std::vector<std::string>& aArgv,
nsTArray<nsCString>& aArgvArray) { nsTArray<nsCString>& aArgvArray) {
for (auto& elt : aArgvArray) { for (auto& elt : aArgvArray) {
aArgv.push_back(elt.get()); aArgv.push_back(elt.get());
@ -108,8 +101,8 @@ PrepareArguments(std::vector<std::string>& aArgv,
} }
// Prepare aOptions->env_map // Prepare aOptions->env_map
inline void inline void PrepareEnv(base::LaunchOptions* aOptions,
PrepareEnv(base::LaunchOptions* aOptions, nsTArray<EnvVar>& aEnvMap) { nsTArray<EnvVar>& aEnvMap) {
for (auto& elt : aEnvMap) { for (auto& elt : aEnvMap) {
nsCString& var = Get<0>(elt); nsCString& var = Get<0>(elt);
nsCString& val = Get<1>(elt); nsCString& val = Get<1>(elt);
@ -120,8 +113,7 @@ PrepareEnv(base::LaunchOptions* aOptions, nsTArray<EnvVar>& aEnvMap) {
} }
// Prepare aOptions->fds_to_remap // Prepare aOptions->fds_to_remap
inline void inline void PrepareFdsRemap(base::LaunchOptions* aOptions,
PrepareFdsRemap(base::LaunchOptions* aOptions,
nsTArray<FdMapping>& aFdsRemap) { nsTArray<FdMapping>& aFdsRemap) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("fds mapping:")); MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("fds mapping:"));
for (auto& elt : aFdsRemap) { for (auto& elt : aFdsRemap) {
@ -137,8 +129,7 @@ PrepareFdsRemap(base::LaunchOptions* aOptions,
/** /**
* Parse a Message to get a list of arguments and fill a LaunchOptions. * Parse a Message to get a list of arguments and fill a LaunchOptions.
*/ */
inline bool inline bool ParseForkNewSubprocess(IPC::Message& aMsg,
ParseForkNewSubprocess(IPC::Message& aMsg,
std::vector<std::string>& aArgv, std::vector<std::string>& aArgv,
base::LaunchOptions* aOptions) { base::LaunchOptions* aOptions) {
if (aMsg.type() != Msg_ForkNewSubprocess__ID) { if (aMsg.type() != Msg_ForkNewSubprocess__ID) {
@ -167,15 +158,12 @@ ParseForkNewSubprocess(IPC::Message& aMsg,
return true; return true;
} }
inline void inline void SanitizeBuffers(IPC::Message& aMsg, std::vector<std::string>& aArgv,
SanitizeBuffers(IPC::Message& aMsg,
std::vector<std::string>& aArgv,
base::LaunchOptions& aOptions) { base::LaunchOptions& aOptions) {
// Clean all buffers in the message to make sure content processes // Clean all buffers in the message to make sure content processes
// not peeking others. // not peeking others.
auto& blist = aMsg.Buffers(); auto& blist = aMsg.Buffers();
for (auto itr = blist.Iter(); for (auto itr = blist.Iter(); !itr.Done();
!itr.Done();
itr.Advance(blist, itr.RemainingInSegment())) { itr.Advance(blist, itr.RemainingInSegment())) {
memset(itr.Data(), 0, itr.RemainingInSegment()); memset(itr.Data(), 0, itr.RemainingInSegment());
} }
@ -198,8 +186,7 @@ SanitizeBuffers(IPC::Message& aMsg,
* It will return in both the fork server process and the new content * It will return in both the fork server process and the new content
* process. |mAppProcBuilder| is null for the fork server. * process. |mAppProcBuilder| is null for the fork server.
*/ */
void void ForkServer::OnMessageReceived(IPC::Message&& message) {
ForkServer::OnMessageReceived(IPC::Message&& message) {
IPC::Message msg(std::move(message)); IPC::Message msg(std::move(message));
std::vector<std::string> argv; std::vector<std::string> argv;
@ -230,8 +217,7 @@ ForkServer::OnMessageReceived(IPC::Message&& message) {
IPC::Message reply(MSG_ROUTING_CONTROL, Reply_ForkNewSubprocess__ID); IPC::Message reply(MSG_ROUTING_CONTROL, Reply_ForkNewSubprocess__ID);
WriteIPDLParam(&reply, nullptr, child_pid); WriteIPDLParam(&reply, nullptr, child_pid);
mTcver->SendInfallible(reply, mTcver->SendInfallible(reply, "failed to send a reply message");
"failed to send a reply message");
// Without this, the content processes that is forked later are // Without this, the content processes that is forked later are
// able to read the content of buffers even the buffers have been // able to read the content of buffers even the buffers have been
@ -250,11 +236,11 @@ ForkServer::OnMessageReceived(IPC::Message&& message) {
* For the later case, aArgc and aArgv are modified to pass the * For the later case, aArgc and aArgv are modified to pass the
* arguments from the chrome process. * arguments from the chrome process.
*/ */
bool bool ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
#ifdef DEBUG #ifdef DEBUG
if (getenv("MOZ_FORKSERVER_WAIT_GDB")) { if (getenv("MOZ_FORKSERVER_WAIT_GDB")) {
printf("Waiting for 30 seconds." printf(
"Waiting for 30 seconds."
" Attach the fork server with gdb %s %d\n", " Attach the fork server with gdb %s %d\n",
(*aArgv)[0], base::GetCurrentProcId()); (*aArgv)[0], base::GetCurrentProcId());
sleep(30); sleep(30);
@ -276,7 +262,8 @@ ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
if (forkserver.HandleMessages()) { if (forkserver.HandleMessages()) {
// In the fork server process // In the fork server process
// The server has stopped. // The server has stopped.
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, ("Terminate the fork server")); MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("Terminate the fork server"));
NS_LogTerm(); NS_LogTerm();
return true; return true;
} }
@ -287,7 +274,8 @@ ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
} }
#ifdef DEBUG #ifdef DEBUG
if (sleep_newproc) { if (sleep_newproc) {
printf("Waiting for 30 seconds." printf(
"Waiting for 30 seconds."
" Attach the new process with gdb %s %d\n", " Attach the new process with gdb %s %d\n",
(*aArgv)[0], base::GetCurrentProcId()); (*aArgv)[0], base::GetCurrentProcId());
sleep(30); sleep(30);
@ -303,7 +291,8 @@ ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
forkserver.mAppProcBuilder->InitAppProcess(aArgc, aArgv); forkserver.mAppProcBuilder->InitAppProcess(aArgc, aArgv);
forkserver.mAppProcBuilder.reset(); 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. // Open log files again with right names and the new PID.
nsTraceRefcnt::ResetLogFiles((*aArgv)[*aArgc - 1]); nsTraceRefcnt::ResetLogFiles((*aArgv)[*aArgc - 1]);
@ -311,5 +300,5 @@ ForkServer::RunForkServer(int* aArgc, char*** aArgv) {
return false; return false;
} }
} } // namespace ipc
} } // namespace mozilla

4
ipc/glue/ForkServer.h
View file

@ -38,7 +38,7 @@ enum {
Reply_ForkNewSubprocess__ID, Reply_ForkNewSubprocess__ID,
}; };
} } // namespace ipc
} } // namespace mozilla
#endif // __FORKSERVER_H_ #endif // __FORKSERVER_H_

44
ipc/glue/ForkServiceChild.cpp
View file

@ -19,8 +19,7 @@ extern LazyLogModule gForkServiceLog;
mozilla::UniquePtr<ForkServiceChild> ForkServiceChild::sForkServiceChild; mozilla::UniquePtr<ForkServiceChild> ForkServiceChild::sForkServiceChild;
void void ForkServiceChild::StartForkServer() {
ForkServiceChild::StartForkServer() {
std::vector<std::string> extraArgs; std::vector<std::string> extraArgs;
GeckoChildProcessHost* subprocess = GeckoChildProcessHost* subprocess =
@ -41,14 +40,10 @@ ForkServiceChild::StartForkServer() {
subprocess->GetChannel()->Close(); subprocess->GetChannel()->Close();
} }
void void ForkServiceChild::StopForkServer() { sForkServiceChild = nullptr; }
ForkServiceChild::StopForkServer() {
sForkServiceChild = nullptr;
}
ForkServiceChild::ForkServiceChild(int aFd, GeckoChildProcessHost* aProcess) ForkServiceChild::ForkServiceChild(int aFd, GeckoChildProcessHost* aProcess)
: mWaitForHello(true) : mWaitForHello(true), mProcess(aProcess) {
, mProcess(aProcess) {
mTcver = MakeUnique<MiniTransceiver>(aFd); mTcver = MakeUnique<MiniTransceiver>(aFd);
} }
@ -57,11 +52,9 @@ ForkServiceChild::~ForkServiceChild() {
close(mTcver->GetFD()); close(mTcver->GetFD());
} }
bool bool ForkServiceChild::SendForkNewSubprocess(
ForkServiceChild::SendForkNewSubprocess(const nsTArray<nsCString>& aArgv, const nsTArray<nsCString>& aArgv, const nsTArray<EnvVar>& aEnvMap,
const nsTArray<EnvVar>& aEnvMap, const nsTArray<FdMapping>& aFdsRemap, pid_t* aPid) {
const nsTArray<FdMapping>& aFdsRemap,
pid_t* aPid) {
if (mWaitForHello) { if (mWaitForHello) {
// IPC::Channel created by the GeckoChildProcessHost has // IPC::Channel created by the GeckoChildProcessHost has
// already send a HELLO. It is expected to receive a hello // already send a HELLO. It is expected to receive a hello
@ -97,8 +90,7 @@ ForkServiceChild::SendForkNewSubprocess(const nsTArray<nsCString>& aArgv,
return true; return true;
} }
void void ForkServiceChild::OnMessageReceived(IPC::Message&& message) {
ForkServiceChild::OnMessageReceived(IPC::Message&& message) {
if (message.type() != Reply_ForkNewSubprocess__ID) { if (message.type() != Reply_ForkNewSubprocess__ID) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose, MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("unknown reply type %d", message.type())); ("unknown reply type %d", message.type()));
@ -117,14 +109,11 @@ NS_IMPL_ISUPPORTS(ForkServerLauncher, nsIObserver)
bool ForkServerLauncher::mHaveStartedClient = false; bool ForkServerLauncher::mHaveStartedClient = false;
StaticRefPtr<ForkServerLauncher> ForkServerLauncher::mSingleton; StaticRefPtr<ForkServerLauncher> ForkServerLauncher::mSingleton;
ForkServerLauncher::ForkServerLauncher() { ForkServerLauncher::ForkServerLauncher() {}
}
ForkServerLauncher::~ForkServerLauncher() { ForkServerLauncher::~ForkServerLauncher() {}
}
already_AddRefed<ForkServerLauncher> already_AddRefed<ForkServerLauncher> ForkServerLauncher::Create() {
ForkServerLauncher::Create() {
if (mSingleton == nullptr) { if (mSingleton == nullptr) {
mSingleton = new ForkServerLauncher(); mSingleton = new ForkServerLauncher();
} }
@ -133,19 +122,20 @@ ForkServerLauncher::Create() {
} }
NS_IMETHODIMP NS_IMETHODIMP
ForkServerLauncher::Observe(nsISupports* aSubject, ForkServerLauncher::Observe(nsISupports* aSubject, const char* aTopic,
const char* aTopic,
const char16_t* aData) { const char16_t* aData) {
if (!mHaveStartedClient && strcmp(aTopic, NS_XPCOM_STARTUP_CATEGORY) == 0) { if (!mHaveStartedClient && strcmp(aTopic, NS_XPCOM_STARTUP_CATEGORY) == 0) {
mHaveStartedClient = true; mHaveStartedClient = true;
ForkServiceChild::StartForkServer(); ForkServiceChild::StartForkServer();
nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService(); nsCOMPtr<nsIObserverService> obsSvc =
mozilla::services::GetObserverService();
MOZ_ASSERT(obsSvc != nullptr); MOZ_ASSERT(obsSvc != nullptr);
obsSvc->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); obsSvc->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
} }
if (mHaveStartedClient && strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) { if (mHaveStartedClient &&
strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
mHaveStartedClient = false; mHaveStartedClient = false;
ForkServiceChild::StopForkServer(); ForkServiceChild::StopForkServer();
@ -155,5 +145,5 @@ ForkServerLauncher::Observe(nsISupports* aSubject,
return NS_OK; return NS_OK;
} }
} } // namespace ipc
} } // namespace mozilla

10
ipc/glue/ForkServiceChild.h
View file

@ -42,11 +42,9 @@ public:
* \param aPid returns the PID of the content process created. * \param aPid returns the PID of the content process created.
* \return true if success. * \return true if success.
*/ */
bool SendForkNewSubprocess( bool SendForkNewSubprocess(const nsTArray<nsCString>& aArgv,
const nsTArray<nsCString>& aArgv,
const nsTArray<EnvVar>& aEnvMap, const nsTArray<EnvVar>& aEnvMap,
const nsTArray<FdMapping>& aFdsRemap, const nsTArray<FdMapping>& aFdsRemap, pid_t* aPid);
pid_t* aPid);
/** /**
* Create a fork server process and the singleton of this class. * Create a fork server process and the singleton of this class.
@ -91,7 +89,7 @@ private:
static StaticRefPtr<ForkServerLauncher> mSingleton; static StaticRefPtr<ForkServerLauncher> mSingleton;
}; };
} } // namespace ipc
} } // namespace mozilla
#endif /* __FORKSERVICE_CHILD_H_ */ #endif /* __FORKSERVICE_CHILD_H_ */

6
ipc/glue/GeckoChildProcessHost.cpp
View file

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

7
ipc/glue/IPDLParamTraits.h
View file

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

62
ipc/glue/MiniTransceiver.cpp
View file

@ -32,10 +32,10 @@ MiniTransceiver::MiniTransceiver(int aFd, DataBufferClear aDataBufClear)
namespace { 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 static void InitMsgHdr(msghdr* aHdr, int aIOVSize, int aMaxNumFds) {
InitMsgHdr(msghdr* aHdr, int aIOVSize, int aMaxNumFds) {
aHdr->msg_name = nullptr; aHdr->msg_name = nullptr;
aHdr->msg_namelen = 0; aHdr->msg_namelen = 0;
aHdr->msg_flags = 0; aHdr->msg_flags = 0;
@ -54,16 +54,14 @@ InitMsgHdr(msghdr* aHdr, int aIOVSize, int aMaxNumFds) {
/** /**
* Delete resources allocated by InitMsgHdr(). * Delete resources allocated by InitMsgHdr().
*/ */
static void static void DeinitMsgHdr(msghdr* aHdr) {
DeinitMsgHdr(msghdr* aHdr) {
delete aHdr->msg_iov; delete aHdr->msg_iov;
delete static_cast<char*>(aHdr->msg_control); delete static_cast<char*>(aHdr->msg_control);
} }
} } // namespace
void void MiniTransceiver::PrepareFDs(msghdr* aHdr, IPC::Message& aMsg) {
MiniTransceiver::PrepareFDs(msghdr* aHdr, IPC::Message& aMsg) {
// Set control buffer to send file descriptors of the Message. // Set control buffer to send file descriptors of the Message.
int num_fds = aMsg.file_descriptor_set()->size(); int num_fds = aMsg.file_descriptor_set()->size();
@ -79,14 +77,12 @@ MiniTransceiver::PrepareFDs(msghdr* aHdr, IPC::Message& aMsg) {
aMsg.header()->num_fds = num_fds; aMsg.header()->num_fds = num_fds;
} }
size_t size_t MiniTransceiver::PrepareBuffers(msghdr* aHdr, IPC::Message& aMsg) {
MiniTransceiver::PrepareBuffers(msghdr* aHdr, IPC::Message& aMsg) {
// Set iovec to send for all buffers of the Message. // Set iovec to send for all buffers of the Message.
iovec* iov = aHdr->msg_iov; iovec* iov = aHdr->msg_iov;
size_t iovlen = 0; size_t iovlen = 0;
size_t bytes_to_send = 0; size_t bytes_to_send = 0;
for (Pickle::BufferList::IterImpl iter(aMsg.Buffers()); for (Pickle::BufferList::IterImpl iter(aMsg.Buffers()); !iter.Done();
!iter.Done();
iter.Advance(aMsg.Buffers(), iter.RemainingInSegment())) { iter.Advance(aMsg.Buffers(), iter.RemainingInSegment())) {
char* data = iter.Data(); char* data = iter.Data();
size_t size = iter.RemainingInSegment(); size_t size = iter.RemainingInSegment();
@ -102,18 +98,18 @@ MiniTransceiver::PrepareBuffers(msghdr* aHdr, IPC::Message& aMsg) {
return bytes_to_send; return bytes_to_send;
} }
bool bool MiniTransceiver::Send(IPC::Message& aMsg) {
MiniTransceiver::Send(IPC::Message& aMsg) {
#ifdef DEBUG #ifdef DEBUG
if (mState == STATE_SENDING) { if (mState == STATE_SENDING) {
MOZ_CRASH("STATE_SENDING: It violates of request-response and no concurrent rules"); MOZ_CRASH(
"STATE_SENDING: It violates of request-response and no concurrent "
"rules");
} }
mState = STATE_SENDING; mState = STATE_SENDING;
#endif #endif
auto clean_fdset = MakeScopeExit([&] { auto clean_fdset =
aMsg.file_descriptor_set()->CommitAll(); MakeScopeExit([&] { aMsg.file_descriptor_set()->CommitAll(); });
});
int num_fds = aMsg.file_descriptor_set()->size(); int num_fds = aMsg.file_descriptor_set()->size();
msghdr hdr; msghdr hdr;
@ -132,23 +128,22 @@ MiniTransceiver::Send(IPC::Message& aMsg) {
NS_WARNING(error); NS_WARNING(error);
return false; return false;
} }
MOZ_ASSERT(bytes_written == (ssize_t)bytes_to_send, "The message is too big?!"); MOZ_ASSERT(bytes_written == (ssize_t)bytes_to_send,
"The message is too big?!");
return true; return true;
} }
unsigned unsigned MiniTransceiver::RecvFDs(msghdr* aHdr, int* aAllFds,
MiniTransceiver::RecvFDs(msghdr* aHdr, int* aAllFds, unsigned aMaxFds) { unsigned aMaxFds) {
if (aHdr->msg_controllen == 0) { if (aHdr->msg_controllen == 0) {
return 0; return 0;
} }
unsigned num_all_fds = 0; unsigned num_all_fds = 0;
for (cmsghdr* cmsg = CMSG_FIRSTHDR(aHdr); for (cmsghdr* cmsg = CMSG_FIRSTHDR(aHdr); cmsg;
cmsg;
cmsg = CMSG_NXTHDR(aHdr, cmsg)) { cmsg = CMSG_NXTHDR(aHdr, cmsg)) {
MOZ_ASSERT(cmsg->cmsg_level == SOL_SOCKET && MOZ_ASSERT(cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS,
cmsg->cmsg_type == SCM_RIGHTS,
"Accept only SCM_RIGHTS to receive file descriptors"); "Accept only SCM_RIGHTS to receive file descriptors");
unsigned payload_sz = cmsg->cmsg_len - CMSG_LEN(0); unsigned payload_sz = cmsg->cmsg_len - CMSG_LEN(0);
@ -165,9 +160,9 @@ MiniTransceiver::RecvFDs(msghdr* aHdr, int* aAllFds, unsigned aMaxFds) {
return num_all_fds; return num_all_fds;
} }
bool bool MiniTransceiver::RecvData(char* aDataBuf, size_t aBufSize,
MiniTransceiver::RecvData(char* aDataBuf, size_t aBufSize, uint32_t* aMsgSize, uint32_t* aMsgSize, int* aFdsBuf,
int* aFdsBuf, unsigned aMaxFds, unsigned* aNumFds) { unsigned aMaxFds, unsigned* aNumFds) {
msghdr hdr; msghdr hdr;
InitMsgHdr(&hdr, 1, aMaxFds); InitMsgHdr(&hdr, 1, aMaxFds);
@ -207,11 +202,12 @@ MiniTransceiver::RecvData(char* aDataBuf, size_t aBufSize, uint32_t* aMsgSize,
return true; return true;
} }
bool bool MiniTransceiver::Recv(IPC::Message& aMsg) {
MiniTransceiver::Recv(IPC::Message& aMsg) {
#ifdef DEBUG #ifdef DEBUG
if (mState == STATE_RECEIVING) { if (mState == STATE_RECEIVING) {
MOZ_CRASH("STATE_RECEIVING: It violates of request-response and no concurrent rules"); MOZ_CRASH(
"STATE_RECEIVING: It violates of request-response and no concurrent "
"rules");
} }
mState = STATE_RECEIVING; mState = STATE_RECEIVING;
#endif #endif
@ -221,8 +217,8 @@ MiniTransceiver::Recv(IPC::Message& aMsg) {
int all_fds[kMaxNumFds]; int all_fds[kMaxNumFds];
unsigned num_all_fds = 0; unsigned num_all_fds = 0;
if (!RecvData(databuf.get(), kMaxDataSize, &msgsz, if (!RecvData(databuf.get(), kMaxDataSize, &msgsz, all_fds, kMaxDataSize,
all_fds, kMaxDataSize, &num_all_fds)) { &num_all_fds)) {
return false; return false;
} }

12
ipc/glue/MiniTransceiver.h
View file

@ -14,10 +14,7 @@ struct msghdr;
namespace mozilla { namespace mozilla {
namespace ipc { namespace ipc {
enum class DataBufferClear { enum class DataBufferClear { None, AfterReceiving };
None,
AfterReceiving
};
/** /**
* This simple implementation handles the transmissions of IPC * This simple implementation handles the transmissions of IPC
@ -37,7 +34,8 @@ public:
* \param aClearDataBuf is true to clear data buffers after * \param aClearDataBuf is true to clear data buffers after
* receiving a message. * receiving a message.
*/ */
explicit MiniTransceiver(int aFd, DataBufferClear aDataBufClear = DataBufferClear::None); explicit MiniTransceiver(
int aFd, DataBufferClear aDataBufClear = DataBufferClear::None);
bool Send(IPC::Message& aMsg); bool Send(IPC::Message& aMsg);
inline bool SendInfallible(IPC::Message& aMsg, const char* aCrashMessage) { inline bool SendInfallible(IPC::Message& aMsg, const char* aCrashMessage) {
@ -113,7 +111,7 @@ private:
DataBufferClear mDataBufClear; DataBufferClear mDataBufClear;
}; };
} // ipc } // namespace ipc
} // mozilla } // namespace mozilla
#endif // __MINITRANSCEIVER_H_ #endif // __MINITRANSCEIVER_H_

6
layout/base/nsLayoutUtils.cpp
View file

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

6
layout/generic/nsImageFrame.cpp
View file

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

9
layout/mathml/nsMathMLContainerFrame.h
View file

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

3
layout/mathml/nsMathMLmtableFrame.h
View file

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

4
layout/xul/nsBoxFrame.h
View file

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

3
media/webrtc/signaling/src/media-conduit/VideoConduit.h
View file

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

3
media/webrtc/signaling/src/peerconnection/RTCStatsIdGenerator.h
View file

@ -16,6 +16,7 @@ public:
RTCStatsIdGenerator(); RTCStatsIdGenerator();
nsString Id(const nsString& aKey); nsString Id(const nsString& aKey);
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RTCStatsIdGenerator); NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RTCStatsIdGenerator);
private: private:
virtual ~RTCStatsIdGenerator(){}; virtual ~RTCStatsIdGenerator(){};
nsString Generate(); nsString Generate();
@ -25,5 +26,5 @@ private:
std::map<nsString, nsString> mAllocated; std::map<nsString, nsString> mAllocated;
}; };
} } // namespace mozilla
#endif #endif

4
mozglue/misc/NativeNt.h
View file

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

4
netwerk/system/android/nsAndroidNetworkLinkService.cpp
View file

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

4
netwerk/system/linux/nsNetworkLinkService.cpp
View file

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

5
netwerk/test/fuzz/TestHttpFuzzing.cpp
View file

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

19
security/sandbox/linux/launch/SandboxLaunch.cpp
View file

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

3
toolkit/xre/nsEmbedFunctions.cpp
View file

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

7
widget/windows/ToastNotificationHandler.cpp
View file

@ -174,8 +174,8 @@ ComPtr<IXmlDocument> ToastNotificationHandler::InitializeXmlForTemplate(
return toastXml; return toastXml;
} }
nsresult nsresult ToastNotificationHandler::InitAlertAsync(
ToastNotificationHandler::InitAlertAsync(nsIAlertNotification *aAlert) { nsIAlertNotification* aAlert) {
return aAlert->LoadImage(/* aTimeout = */ 0, this, /* aUserData = */ nullptr, return aAlert->LoadImage(/* aTimeout = */ 0, this, /* aUserData = */ nullptr,
getter_AddRefs(mImageRequest)); getter_AddRefs(mImageRequest));
} }
@ -419,8 +419,7 @@ bool ToastNotificationHandler::CreateWindowsNotificationFromXml(
return true; return true;
} }
void void ToastNotificationHandler::SendFinished() {
ToastNotificationHandler::SendFinished() {
if (!mSentFinished && mAlertListener) { if (!mSentFinished && mAlertListener) {
mAlertListener->Observe(nullptr, "alertfinished", mCookie.get()); mAlertListener->Observe(nullptr, "alertfinished", mCookie.get());
} }

11
xpcom/base/nsTraceRefcnt.cpp
View file

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

3
xpcom/threads/nsThreadManager.h
View file

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