wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-29 03:47:31 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1751 - Remove Mac code behind MOZ_WIDGET_TOOLKIT == 'cocoa'

Browse source
This commit is contained in:
Moonchild 2021-06-21 17:52:42 +00:00 • committed by roytam1
commit ba00d14c12
382 changed files with 36 additions and 22824 deletions
Download patch file Download diff file Expand all files Collapse all files

21
toolkit/system/osxproxy/ProxyUtils.h
View file

@ -1,21 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#ifndef mozilla_toolkit_system_osxproxy_ProxyUtils_h
#define mozilla_toolkit_system_osxproxy_ProxyUtils_h
#include "nsStringGlue.h"
namespace mozilla {
namespace toolkit {
namespace system {
bool IsHostProxyEntry(const nsACString& aHost, const nsACString& aOverride);
} // namespace system
} // namespace toolkit
} // namespace mozilla
#endif // mozilla_toolkit_system_osxproxy_ProxyUtils_h

182
toolkit/system/osxproxy/ProxyUtils.mm
View file

@ -1,182 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 "ProxyUtils.h"
#include "nsTArray.h"
#include "prnetdb.h"
#include "prtypes.h"
namespace mozilla {
namespace toolkit {
namespace system {
/**
* Normalize the short IP form into the complete form.
* For example, it converts "192.168" into "192.168.0.0"
*/
static bool
NormalizeAddr(const nsACString& aAddr, nsCString& aNormalized)
{
nsTArray<nsCString> addr;
if (!ParseString(aAddr, '.', addr)) {
return false;
}
aNormalized = "";
for (uint32_t i = 0; i < 4; ++i) {
if (i != 0) {
aNormalized.Append(".");
}
if (i < addr.Length()) {
aNormalized.Append(addr[i]);
} else {
aNormalized.Append("0");
}
}
return true;
}
static PRUint32
MaskIPv4Addr(PRUint32 aAddr, uint16_t aMaskLen)
{
if (aMaskLen == 32) {
return aAddr;
}
return PR_htonl(PR_ntohl(aAddr) & (~0L << (32 - aMaskLen)));
}
static void
MaskIPv6Addr(PRIPv6Addr& aAddr, uint16_t aMaskLen)
{
if (aMaskLen == 128) {
return;
}
if (aMaskLen > 96) {
aAddr.pr_s6_addr32[3] = PR_htonl(
PR_ntohl(aAddr.pr_s6_addr32[3]) & (~0L << (128 - aMaskLen)));
} else if (aMaskLen > 64) {
aAddr.pr_s6_addr32[3] = 0;
aAddr.pr_s6_addr32[2] = PR_htonl(
PR_ntohl(aAddr.pr_s6_addr32[2]) & (~0L << (96 - aMaskLen)));
} else if (aMaskLen > 32) {
aAddr.pr_s6_addr32[3] = 0;
aAddr.pr_s6_addr32[2] = 0;
aAddr.pr_s6_addr32[1] = PR_htonl(
PR_ntohl(aAddr.pr_s6_addr32[1]) & (~0L << (64 - aMaskLen)));
} else {
aAddr.pr_s6_addr32[3] = 0;
aAddr.pr_s6_addr32[2] = 0;
aAddr.pr_s6_addr32[1] = 0;
aAddr.pr_s6_addr32[0] = PR_htonl(
PR_ntohl(aAddr.pr_s6_addr32[0]) & (~0L << (32 - aMaskLen)));
}
return;
}
static bool
IsMatchMask(const nsACString& aHost, const nsACString& aOverride)
{
nsresult rv;
auto tokenEnd = aOverride.FindChar('/');
if (tokenEnd == -1) {
return false;
}
nsAutoCString prefixStr(Substring(aOverride,
tokenEnd + 1,
aOverride.Length() - tokenEnd - 1));
auto maskLen = prefixStr.ToInteger(&rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return false;
}
nsAutoCString override(aOverride);
if (!NormalizeAddr(Substring(aOverride, 0, tokenEnd), override)) {
return false;
}
PRNetAddr prAddrHost;
PRNetAddr prAddrOverride;
if (PR_SUCCESS != PR_StringToNetAddr(PromiseFlatCString(aHost).get(),
&prAddrHost) ||
PR_SUCCESS != PR_StringToNetAddr(override.get(),
&prAddrOverride)) {
return false;
}
if (prAddrHost.raw.family == PR_AF_INET &&
prAddrOverride.raw.family == PR_AF_INET) {
return MaskIPv4Addr(prAddrHost.inet.ip, maskLen) ==
MaskIPv4Addr(prAddrOverride.inet.ip, maskLen);
}
else if (prAddrHost.raw.family == PR_AF_INET6 &&
prAddrOverride.raw.family == PR_AF_INET6) {
MaskIPv6Addr(prAddrHost.ipv6.ip, maskLen);
MaskIPv6Addr(prAddrOverride.ipv6.ip, maskLen);
return memcmp(&prAddrHost.ipv6.ip,
&prAddrOverride.ipv6.ip,
sizeof(PRIPv6Addr)) == 0;
}
return false;
}
static bool
IsMatchWildcard(const nsACString& aHost, const nsACString& aOverride)
{
nsAutoCString host(aHost);
nsAutoCString override(aOverride);
int32_t overrideLength = override.Length();
int32_t tokenStart = 0;
int32_t offset = 0;
bool star = false;
while (tokenStart < overrideLength) {
int32_t tokenEnd = override.FindChar('*', tokenStart);
if (tokenEnd == tokenStart) {
// Star is the first character in the token.
star = true;
tokenStart++;
// If the character following the '*' is a '.' character then skip
// it so that "*.foo.com" allows "foo.com".
if (override.FindChar('.', tokenStart) == tokenStart) {
nsAutoCString token(Substring(override,
tokenStart + 1,
overrideLength - tokenStart - 1));
if (host.Equals(token)) {
return true;
}
}
} else {
if (tokenEnd == -1) {
tokenEnd = overrideLength; // no '*' char, match rest of string
}
nsAutoCString token(Substring(override, tokenStart, tokenEnd - tokenStart));
offset = host.Find(token, offset);
if (offset == -1 || (!star && offset)) {
return false;
}
star = false;
tokenStart = tokenEnd;
offset += token.Length();
}
}
return (star || (offset == static_cast<int32_t>(host.Length())));
}
bool
IsHostProxyEntry(const nsACString& aHost, const nsACString& aOverride)
{
return IsMatchMask(aHost, aOverride) || IsMatchWildcard(aHost, aOverride);
}
} // namespace system
} // namespace toolkit
} // namespace mozilla

13
toolkit/system/osxproxy/moz.build
View file

@ -1,13 +0,0 @@
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
# 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/.
TEST_DIRS += ['tests/gtest']
SOURCES += [
'nsOSXSystemProxySettings.mm',
'ProxyUtils.mm',
]
FINAL_LIBRARY = 'xul'

326
toolkit/system/osxproxy/nsOSXSystemProxySettings.mm
View file

@ -1,326 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et: */
/* 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/. */
#import <Cocoa/Cocoa.h>
#import <SystemConfiguration/SystemConfiguration.h>
#include "nsISystemProxySettings.h"
#include "mozilla/ModuleUtils.h"
#include "nsIServiceManager.h"
#include "nsPrintfCString.h"
#include "nsNetCID.h"
#include "nsISupportsPrimitives.h"
#include "nsIURI.h"
#include "nsObjCExceptions.h"
#include "mozilla/Attributes.h"
#include "ProxyUtils.h"
class nsOSXSystemProxySettings final : public nsISystemProxySettings {
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISYSTEMPROXYSETTINGS
nsOSXSystemProxySettings();
nsresult Init();
// called by OSX when the proxy settings have changed
void ProxyHasChanged();
// is there a PAC url specified in the system configuration
bool IsAutoconfigEnabled() const;
// retrieve the pac url
nsresult GetAutoconfigURL(nsAutoCString& aResult) const;
// Find the SystemConfiguration proxy & port for a given URI
nsresult FindSCProxyPort(const nsACString &aScheme, nsACString& aResultHost, int32_t& aResultPort, bool& aResultSocksProxy);
// is host:port on the proxy exception list?
bool IsInExceptionList(const nsACString& aHost) const;
private:
~nsOSXSystemProxySettings();
SCDynamicStoreContext mContext;
SCDynamicStoreRef mSystemDynamicStore;
NSDictionary* mProxyDict;
// Mapping of URI schemes to SystemConfiguration keys
struct SchemeMapping {
const char* mScheme;
CFStringRef mEnabled;
CFStringRef mHost;
CFStringRef mPort;
bool mIsSocksProxy;
};
static const SchemeMapping gSchemeMappingList[];
};
NS_IMPL_ISUPPORTS(nsOSXSystemProxySettings, nsISystemProxySettings)
NS_IMETHODIMP
nsOSXSystemProxySettings::GetMainThreadOnly(bool *aMainThreadOnly)
{
*aMainThreadOnly = true;
return NS_OK;
}
// Mapping of URI schemes to SystemConfiguration keys
const nsOSXSystemProxySettings::SchemeMapping nsOSXSystemProxySettings::gSchemeMappingList[] = {
{"http", kSCPropNetProxiesHTTPEnable, kSCPropNetProxiesHTTPProxy, kSCPropNetProxiesHTTPPort, false},
{"https", kSCPropNetProxiesHTTPSEnable, kSCPropNetProxiesHTTPSProxy, kSCPropNetProxiesHTTPSPort, false},
{"ftp", kSCPropNetProxiesFTPEnable, kSCPropNetProxiesFTPProxy, kSCPropNetProxiesFTPPort, false},
{"socks", kSCPropNetProxiesSOCKSEnable, kSCPropNetProxiesSOCKSProxy, kSCPropNetProxiesSOCKSPort, true},
{NULL, NULL, NULL, NULL, false},
};
static void
ProxyHasChangedWrapper(SCDynamicStoreRef aStore, CFArrayRef aChangedKeys, void* aInfo)
{
static_cast<nsOSXSystemProxySettings*>(aInfo)->ProxyHasChanged();
}
nsOSXSystemProxySettings::nsOSXSystemProxySettings()
: mSystemDynamicStore(NULL), mProxyDict(NULL)
{
mContext = (SCDynamicStoreContext){0, this, NULL, NULL, NULL};
}
nsresult
nsOSXSystemProxySettings::Init()
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
// Register for notification of proxy setting changes
// See: http://developer.apple.com/documentation/Networking/Conceptual/CFNetwork/CFStreamTasks/chapter_4_section_5.html
mSystemDynamicStore = SCDynamicStoreCreate(NULL, CFSTR("Mozilla"), ProxyHasChangedWrapper, &mContext);
if (!mSystemDynamicStore)
return NS_ERROR_FAILURE;
// Set up the store to monitor any changes to the proxies
CFStringRef proxiesKey = SCDynamicStoreKeyCreateProxies(NULL);
if (!proxiesKey)
return NS_ERROR_FAILURE;
CFArrayRef keyArray = CFArrayCreate(NULL, (const void**)(&proxiesKey), 1, &kCFTypeArrayCallBacks);
CFRelease(proxiesKey);
if (!keyArray)
return NS_ERROR_FAILURE;
SCDynamicStoreSetNotificationKeys(mSystemDynamicStore, keyArray, NULL);
CFRelease(keyArray);
// Add the dynamic store to the run loop
CFRunLoopSourceRef storeRLSource = SCDynamicStoreCreateRunLoopSource(NULL, mSystemDynamicStore, 0);
if (!storeRLSource)
return NS_ERROR_FAILURE;
CFRunLoopAddSource(CFRunLoopGetCurrent(), storeRLSource, kCFRunLoopCommonModes);
CFRelease(storeRLSource);
// Load the initial copy of proxy info
mProxyDict = (NSDictionary*)SCDynamicStoreCopyProxies(mSystemDynamicStore);
if (!mProxyDict)
return NS_ERROR_FAILURE;
return NS_OK;
NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
}
nsOSXSystemProxySettings::~nsOSXSystemProxySettings()
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
[mProxyDict release];
if (mSystemDynamicStore) {
// Invalidate the dynamic store's run loop source
// to get the store out of the run loop
CFRunLoopSourceRef rls = SCDynamicStoreCreateRunLoopSource(NULL, mSystemDynamicStore, 0);
if (rls) {
CFRunLoopSourceInvalidate(rls);
CFRelease(rls);
}
CFRelease(mSystemDynamicStore);
}
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void
nsOSXSystemProxySettings::ProxyHasChanged()
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
[mProxyDict release];
mProxyDict = (NSDictionary*)SCDynamicStoreCopyProxies(mSystemDynamicStore);
NS_OBJC_END_TRY_ABORT_BLOCK;
}
nsresult
nsOSXSystemProxySettings::FindSCProxyPort(const nsACString &aScheme, nsACString& aResultHost, int32_t& aResultPort, bool& aResultSocksProxy)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
NS_ENSURE_TRUE(mProxyDict != NULL, NS_ERROR_FAILURE);
for (const SchemeMapping* keys = gSchemeMappingList; keys->mScheme != NULL; ++keys) {
// Check for matching scheme (when appropriate)
if (strcasecmp(keys->mScheme, PromiseFlatCString(aScheme).get()) &&
!keys->mIsSocksProxy)
continue;
// Check the proxy is enabled
NSNumber* enabled = [mProxyDict objectForKey:(NSString*)keys->mEnabled];
NS_ENSURE_TRUE(enabled == NULL || [enabled isKindOfClass:[NSNumber class]], NS_ERROR_FAILURE);
if ([enabled intValue] == 0)
continue;
// Get the proxy host
NSString* host = [mProxyDict objectForKey:(NSString*)keys->mHost];
if (host == NULL)
break;
NS_ENSURE_TRUE([host isKindOfClass:[NSString class]], NS_ERROR_FAILURE);
aResultHost.Assign([host UTF8String]);
// Get the proxy port
NSNumber* port = [mProxyDict objectForKey:(NSString*)keys->mPort];
NS_ENSURE_TRUE([port isKindOfClass:[NSNumber class]], NS_ERROR_FAILURE);
aResultPort = [port intValue];
aResultSocksProxy = keys->mIsSocksProxy;
return NS_OK;
}
return NS_ERROR_FAILURE;
NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
}
bool
nsOSXSystemProxySettings::IsAutoconfigEnabled() const
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
NSNumber* value = [mProxyDict objectForKey:(NSString*)kSCPropNetProxiesProxyAutoConfigEnable];
NS_ENSURE_TRUE(value == NULL || [value isKindOfClass:[NSNumber class]], false);
return ([value intValue] != 0);
NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false);
}
nsresult
nsOSXSystemProxySettings::GetAutoconfigURL(nsAutoCString& aResult) const
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
NSString* value = [mProxyDict objectForKey:(NSString*)kSCPropNetProxiesProxyAutoConfigURLString];
if (value != NULL) {
NS_ENSURE_TRUE([value isKindOfClass:[NSString class]], NS_ERROR_FAILURE);
aResult.Assign([value UTF8String]);
return NS_OK;
}
return NS_ERROR_FAILURE;
NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
}
bool
nsOSXSystemProxySettings::IsInExceptionList(const nsACString& aHost) const
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
NS_ENSURE_TRUE(mProxyDict != NULL, false);
NSArray* exceptionList = [mProxyDict objectForKey:(NSString*)kSCPropNetProxiesExceptionsList];
NS_ENSURE_TRUE(exceptionList == NULL || [exceptionList isKindOfClass:[NSArray class]], false);
NSEnumerator* exceptionEnumerator = [exceptionList objectEnumerator];
NSString* currentValue = NULL;
while ((currentValue = [exceptionEnumerator nextObject])) {
NS_ENSURE_TRUE([currentValue isKindOfClass:[NSString class]], false);
nsAutoCString overrideStr([currentValue UTF8String]);
if (mozilla::toolkit::system::IsHostProxyEntry(aHost, overrideStr))
return true;
}
NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false);
}
nsresult
nsOSXSystemProxySettings::GetPACURI(nsACString& aResult)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
NS_ENSURE_TRUE(mProxyDict != NULL, NS_ERROR_FAILURE);
nsAutoCString pacUrl;
if (IsAutoconfigEnabled() && NS_SUCCEEDED(GetAutoconfigURL(pacUrl))) {
aResult.Assign(pacUrl);
return NS_OK;
}
return NS_ERROR_FAILURE;
NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
}
nsresult
nsOSXSystemProxySettings::GetProxyForURI(const nsACString & aSpec,
const nsACString & aScheme,
const nsACString & aHost,
const int32_t aPort,
nsACString & aResult)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
int32_t proxyPort;
nsAutoCString proxyHost;
bool proxySocks;
nsresult rv = FindSCProxyPort(aScheme, proxyHost, proxyPort, proxySocks);
if (NS_FAILED(rv) || IsInExceptionList(aHost)) {
aResult.AssignLiteral("DIRECT");
} else if (proxySocks) {
aResult.Assign(NS_LITERAL_CSTRING("SOCKS ") + proxyHost + nsPrintfCString(":%d", proxyPort));
} else {
aResult.Assign(NS_LITERAL_CSTRING("PROXY ") + proxyHost + nsPrintfCString(":%d", proxyPort));
}
return NS_OK;
NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
}
#define NS_OSXSYSTEMPROXYSERVICE_CID /* 9afcd4b8-2e0f-41f4-8f1f-3bf0d3cf67de */\
{ 0x9afcd4b8, 0x2e0f, 0x41f4, \
{ 0x8f, 0x1f, 0x3b, 0xf0, 0xd3, 0xcf, 0x67, 0xde } }
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsOSXSystemProxySettings, Init);
NS_DEFINE_NAMED_CID(NS_OSXSYSTEMPROXYSERVICE_CID);
static const mozilla::Module::CIDEntry kOSXSysProxyCIDs[] = {
{ &kNS_OSXSYSTEMPROXYSERVICE_CID, false, NULL, nsOSXSystemProxySettingsConstructor },
{ NULL }
};
static const mozilla::Module::ContractIDEntry kOSXSysProxyContracts[] = {
{ NS_SYSTEMPROXYSETTINGS_CONTRACTID, &kNS_OSXSYSTEMPROXYSERVICE_CID },
{ NULL }
};
static const mozilla::Module kOSXSysProxyModule = {
mozilla::Module::kVersion,
kOSXSysProxyCIDs,
kOSXSysProxyContracts
};
NSMODULE_DEFN(nsOSXProxyModule) = &kOSXSysProxyModule;

41
toolkit/system/osxproxy/tests/gtest/TestProxyBypassRules.cpp
View file

@ -1,41 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 "gtest/gtest.h"
#include "ProxyUtils.h"
using namespace mozilla::toolkit::system;
TEST(OSXProxy, TestProxyBypassRules)
{
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("mozilla.org"), NS_LITERAL_CSTRING("mozilla.org")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("mozilla.org"),NS_LITERAL_CSTRING("*mozilla.org")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("mozilla.org"), NS_LITERAL_CSTRING("*.mozilla.org")));
EXPECT_FALSE(IsHostProxyEntry(NS_LITERAL_CSTRING("notmozilla.org"), NS_LITERAL_CSTRING("*.mozilla.org")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("www.mozilla.org"), NS_LITERAL_CSTRING("*mozilla.org")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("www.mozilla.org"), NS_LITERAL_CSTRING("*.mozilla.org")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("www.mozilla.com"), NS_LITERAL_CSTRING("*.mozilla.*")));
}
TEST(OSXProxy, TestProxyBypassRulesIPv4)
{
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("192.168.1.1"), NS_LITERAL_CSTRING("192.168.1.*")));
EXPECT_FALSE(IsHostProxyEntry(NS_LITERAL_CSTRING("192.168.1.1"), NS_LITERAL_CSTRING("192.168.2.*")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("10.1.2.3"), NS_LITERAL_CSTRING("10.0.0.0/8")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("192.168.192.1"), NS_LITERAL_CSTRING("192.168/16")));
EXPECT_FALSE(IsHostProxyEntry(NS_LITERAL_CSTRING("192.168.192.1"), NS_LITERAL_CSTRING("192.168/17")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("192.168.192.1"), NS_LITERAL_CSTRING("192.168.128/17")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("192.168.1.1"), NS_LITERAL_CSTRING("192.168.1.1/32")));
}
TEST(OSXProxy, TestProxyBypassRulesIPv6)
{
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("2001:0DB8:ABCD:0012:0123:4567:89AB:CDEF"), NS_LITERAL_CSTRING("2001:db8:abcd:0012::0/64")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("2001:0DB8:ABCD:0012:0000:4567:89AB:CDEF"), NS_LITERAL_CSTRING("2001:db8:abcd:0012::0/80")));
EXPECT_FALSE(IsHostProxyEntry(NS_LITERAL_CSTRING("2001:0DB8:ABCD:0012:0123:4567:89AB:CDEF"), NS_LITERAL_CSTRING("2001:db8:abcd:0012::0/80")));
EXPECT_TRUE(IsHostProxyEntry(NS_LITERAL_CSTRING("2001:0DB8:ABCD:0012:0000:0000:89AB:CDEF"), NS_LITERAL_CSTRING("2001:db8:abcd:0012::0/96")));
EXPECT_FALSE(IsHostProxyEntry(NS_LITERAL_CSTRING("2001:0DB8:ABCD:0012:0123:4567:89AB:CDEF"), NS_LITERAL_CSTRING("2001:db8:abcd:0012::0/96")));
}

17
toolkit/system/osxproxy/tests/gtest/moz.build
View file

@ -1,17 +0,0 @@
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
# 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/.
UNIFIED_SOURCES += [
'TestProxyBypassRules.cpp',
]
LOCAL_INCLUDES += [
'/toolkit/system/osxproxy',
]
FINAL_LIBRARY = 'xul-gtest'
if CONFIG['GNU_CXX']:
CXXFLAGS += ['-Wshadow']