mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 01:05:45 +00:00
256c124f94
This was done by: This was done by applying: ``` diff --git a/python/mozbuild/mozbuild/code-analysis/mach_commands.py b/python/mozbuild/mozbuild/code-analysis/mach_commands.py index 789affde7bbf..fe33c4c7d4d1 100644 --- a/python/mozbuild/mozbuild/code-analysis/mach_commands.py +++ b/python/mozbuild/mozbuild/code-analysis/mach_commands.py @@ -2007,7 +2007,7 @@ class StaticAnalysis(MachCommandBase): from subprocess import Popen, PIPE, check_output, CalledProcessError diff_process = Popen(self._get_clang_format_diff_command(commit), stdout=PIPE) - args = [sys.executable, clang_format_diff, "-p1", "-binary=%s" % clang_format] + args = [sys.executable, clang_format_diff, "-p1", "-binary=%s" % clang_format, '-sort-includes'] if not output_file: args.append("-i") ``` Then running `./mach clang-format -c <commit-hash>` Then undoing that patch. Then running check_spidermonkey_style.py --fixup Then running `./mach clang-format` I had to fix four things: * I needed to move <utility> back down in GuardObjects.h because I was hitting obscure problems with our system include wrappers like this: 0:03.94 /usr/include/stdlib.h:550:14: error: exception specification in declaration does not match previous declaration 0:03.94 extern void *realloc (void *__ptr, size_t __size) 0:03.94 ^ 0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/malloc_decls.h:53:1: note: previous declaration is here 0:03.94 MALLOC_DECL(realloc, void*, void*, size_t) 0:03.94 ^ 0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/mozilla/mozalloc.h:22:32: note: expanded from macro 'MALLOC_DECL' 0:03.94 MOZ_MEMORY_API return_type name##_impl(__VA_ARGS__); 0:03.94 ^ 0:03.94 <scratch space>:178:1: note: expanded from here 0:03.94 realloc_impl 0:03.94 ^ 0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/mozmemory_wrap.h:142:41: note: expanded from macro 'realloc_impl' 0:03.94 #define realloc_impl mozmem_malloc_impl(realloc) Which I really didn't feel like digging into. * I had to restore the order of TrustOverrideUtils.h and related files in nss because the .inc files depend on TrustOverrideUtils.h being included earlier. * I had to add a missing include to RollingNumber.h * Also had to partially restore include order in JsepSessionImpl.cpp to avoid some -WError issues due to some static inline functions being defined in a header but not used in the rest of the compilation unit. Differential Revision: https://phabricator.services.mozilla.com/D60327 --HG-- extra : moz-landing-system : lando
157 lines
4.3 KiB
C++
157 lines
4.3 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/mscom/DispatchForwarder.h"
|
|
|
|
#include <oleauto.h>
|
|
|
|
#include <utility>
|
|
|
|
#include "mozilla/mscom/MainThreadInvoker.h"
|
|
|
|
namespace mozilla {
|
|
namespace mscom {
|
|
|
|
/* static */
|
|
HRESULT DispatchForwarder::Create(IInterceptor* aInterceptor,
|
|
STAUniquePtr<IDispatch>& aTarget,
|
|
IUnknown** aOutput) {
|
|
MOZ_ASSERT(aInterceptor && aOutput);
|
|
if (!aOutput) {
|
|
return E_INVALIDARG;
|
|
}
|
|
*aOutput = nullptr;
|
|
if (!aInterceptor) {
|
|
return E_INVALIDARG;
|
|
}
|
|
DispatchForwarder* forwarder = new DispatchForwarder(aInterceptor, aTarget);
|
|
HRESULT hr = forwarder->QueryInterface(IID_IDispatch, (void**)aOutput);
|
|
forwarder->Release();
|
|
return hr;
|
|
}
|
|
|
|
DispatchForwarder::DispatchForwarder(IInterceptor* aInterceptor,
|
|
STAUniquePtr<IDispatch>& aTarget)
|
|
: mRefCnt(1), mInterceptor(aInterceptor), mTarget(std::move(aTarget)) {}
|
|
|
|
DispatchForwarder::~DispatchForwarder() {}
|
|
|
|
HRESULT
|
|
DispatchForwarder::QueryInterface(REFIID riid, void** ppv) {
|
|
if (!ppv) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
// Since this class implements a tearoff, any interfaces that are not
|
|
// IDispatch must be routed to the original object's QueryInterface.
|
|
// This is especially important for IUnknown since COM uses that interface
|
|
// to determine object identity.
|
|
if (riid != IID_IDispatch) {
|
|
return mInterceptor->QueryInterface(riid, ppv);
|
|
}
|
|
|
|
IUnknown* punk = static_cast<IDispatch*>(this);
|
|
*ppv = punk;
|
|
if (!punk) {
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
punk->AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
ULONG
|
|
DispatchForwarder::AddRef() {
|
|
return (ULONG)InterlockedIncrement((LONG*)&mRefCnt);
|
|
}
|
|
|
|
ULONG
|
|
DispatchForwarder::Release() {
|
|
ULONG newRefCnt = (ULONG)InterlockedDecrement((LONG*)&mRefCnt);
|
|
if (newRefCnt == 0) {
|
|
delete this;
|
|
}
|
|
return newRefCnt;
|
|
}
|
|
|
|
HRESULT
|
|
DispatchForwarder::GetTypeInfoCount(UINT* pctinfo) {
|
|
if (!pctinfo) {
|
|
return E_INVALIDARG;
|
|
}
|
|
*pctinfo = 1;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
DispatchForwarder::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) {
|
|
// ITypeInfo as implemented by COM is apartment-neutral, so we don't need
|
|
// to wrap it (yay!)
|
|
if (mTypeInfo) {
|
|
RefPtr<ITypeInfo> copy(mTypeInfo);
|
|
copy.forget(ppTInfo);
|
|
return S_OK;
|
|
}
|
|
HRESULT hr = E_UNEXPECTED;
|
|
auto fn = [&]() -> void { hr = mTarget->GetTypeInfo(iTInfo, lcid, ppTInfo); };
|
|
MainThreadInvoker invoker;
|
|
if (!invoker.Invoke(
|
|
NS_NewRunnableFunction("DispatchForwarder::GetTypeInfo", fn))) {
|
|
return E_UNEXPECTED;
|
|
}
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
mTypeInfo = *ppTInfo;
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
DispatchForwarder::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
|
|
LCID lcid, DISPID* rgDispId) {
|
|
HRESULT hr = E_UNEXPECTED;
|
|
auto fn = [&]() -> void {
|
|
hr = mTarget->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
|
|
};
|
|
MainThreadInvoker invoker;
|
|
if (!invoker.Invoke(
|
|
NS_NewRunnableFunction("DispatchForwarder::GetIDsOfNames", fn))) {
|
|
return E_UNEXPECTED;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
DispatchForwarder::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
|
|
WORD wFlags, DISPPARAMS* pDispParams,
|
|
VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
|
|
UINT* puArgErr) {
|
|
HRESULT hr;
|
|
if (!mInterface) {
|
|
if (!mTypeInfo) {
|
|
return E_UNEXPECTED;
|
|
}
|
|
TYPEATTR* typeAttr = nullptr;
|
|
hr = mTypeInfo->GetTypeAttr(&typeAttr);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
hr = mInterceptor->QueryInterface(typeAttr->guid,
|
|
(void**)getter_AddRefs(mInterface));
|
|
mTypeInfo->ReleaseTypeAttr(typeAttr);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
}
|
|
// We don't invoke IDispatch on the target, but rather on the interceptor!
|
|
hr = ::DispInvoke(mInterface.get(), mTypeInfo, dispIdMember, wFlags,
|
|
pDispParams, pVarResult, pExcepInfo, puArgErr);
|
|
return hr;
|
|
}
|
|
|
|
} // namespace mscom
|
|
} // namespace mozilla
|