The Tor Browser: netwerk/base/src/nsPACMan.cpp@b8a032363ba2 (annotated)

netwerk/base/src/nsPACMan.cpp@b8a032363ba2 (annotated)

netwerk/base/src/nsPACMan.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* 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 "nsPACMan.h"
 #include "nsThreadUtils.h"
 #include "nsIAuthPrompt.h"
 #include "nsIPromptFactory.h"
 #include "nsIHttpChannel.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch.h"
 #include "nsNetUtil.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 #include "nsISystemProxySettings.h"
 #ifdef MOZ_NUWA_PROCESS
 #include "ipc/Nuwa.h"
 #endif
 //-----------------------------------------------------------------------------
 using namespace mozilla;
 using namespace mozilla::net;
 #if defined(PR_LOGGING)
 #endif
 #undef LOG
 #define LOG(args) PR_LOG(GetProxyLog(), PR_LOG_DEBUG, args)
 // The PAC thread does evaluations of both PAC files and
 // nsISystemProxySettings because they can both block the calling thread and we
 // don't want that on the main thread
 // Check to see if the underlying request was not an error page in the case of
 // a HTTP request.  For other types of channels, just return true.
 static bool
 HttpRequestSucceeded(nsIStreamLoader *loader)
 {
   nsCOMPtr<nsIRequest> request;
   loader->GetRequest(getter_AddRefs(request));
   bool result = true;  // default to assuming success
   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(request);
   if (httpChannel)
     httpChannel->GetRequestSucceeded(&result);
   return result;
 }
 //-----------------------------------------------------------------------------
 // The ExecuteCallback runnable is triggered by
 // nsPACManCallback::OnQueryComplete on the Main thread when its completion is
 // discovered on the pac thread
 class ExecuteCallback MOZ_FINAL : public nsRunnable
 {
 public:
   ExecuteCallback(nsPACManCallback *aCallback,
                   nsresult status)
     : mCallback(aCallback)
     , mStatus(status)
   {
   }
   void SetPACString(const nsCString &pacString)
   {
     mPACString = pacString;
   }
   void SetPACURL(const nsCString &pacURL)
   {
     mPACURL = pacURL;
   }
   NS_IMETHODIMP Run()
   {
     mCallback->OnQueryComplete(mStatus, mPACString, mPACURL);
     mCallback = nullptr;
     return NS_OK;
   }
 private:
   nsRefPtr<nsPACManCallback> mCallback;
   nsresult                   mStatus;
   nsCString                  mPACString;
   nsCString                  mPACURL;
 };
 //-----------------------------------------------------------------------------
 // The PAC thread must be deleted from the main thread, this class
 // acts as a proxy to do that, as the PACMan is reference counted
 // and might be destroyed on either thread
 class ShutdownThread MOZ_FINAL : public nsRunnable
 {
 public:
   ShutdownThread(nsIThread *thread)
     : mThread(thread)
   {
   }
   NS_IMETHODIMP Run()
   {
     NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
     mThread->Shutdown();
     return NS_OK;
   }
 private:
   nsCOMPtr<nsIThread> mThread;
 };
 // Dispatch this to wait until the PAC thread shuts down.
 class WaitForThreadShutdown MOZ_FINAL : public nsRunnable
 {
 public:
   explicit WaitForThreadShutdown(nsPACMan *aPACMan)
     : mPACMan(aPACMan)
   {
   }
   NS_IMETHODIMP Run()
   {
     NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
     if (mPACMan->mPACThread) {
       mPACMan->mPACThread->Shutdown();
       mPACMan->mPACThread = nullptr;
     }
     return NS_OK;
   }
 private:
   nsRefPtr<nsPACMan> mPACMan;
 };
 //-----------------------------------------------------------------------------
 // PACLoadComplete allows the PAC thread to tell the main thread that
 // the javascript PAC file has been installed (perhaps unsuccessfully)
 // and that there is no reason to queue executions anymore
 class PACLoadComplete MOZ_FINAL : public nsRunnable
 {
 public:
   PACLoadComplete(nsPACMan *aPACMan)
     : mPACMan(aPACMan)
   {
   }
   NS_IMETHODIMP Run()
   {
     NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
     mPACMan->mLoader = nullptr;
     mPACMan->PostProcessPendingQ();
     return NS_OK;
   }
 private:
     nsRefPtr<nsPACMan> mPACMan;
 };
 //-----------------------------------------------------------------------------
 // ExecutePACThreadAction is used to proxy actions from the main
 // thread onto the PAC thread. There are 3 options: process the queue,
 // cancel the queue, and setup the javascript context with a new PAC file
 class ExecutePACThreadAction MOZ_FINAL : public nsRunnable
 {
 public:
   // by default we just process the queue
   ExecutePACThreadAction(nsPACMan *aPACMan)
     : mPACMan(aPACMan)
     , mCancel(false)
     , mSetupPAC(false)
   { }
   void CancelQueue (nsresult status)
   {
     mCancel = true;
     mCancelStatus = status;
   }
   void SetupPAC (const char *text, uint32_t datalen, nsCString &pacURI)
   {
     mSetupPAC = true;
     mSetupPACData.Assign(text, datalen);
     mSetupPACURI = pacURI;
   }
   NS_IMETHODIMP Run()
   {
     NS_ABORT_IF_FALSE(!NS_IsMainThread(), "wrong thread");
     if (mCancel) {
       mPACMan->CancelPendingQ(mCancelStatus);
       mCancel = false;
       return NS_OK;
     }
     if (mSetupPAC) {
       mSetupPAC = false;
       mPACMan->mPAC.Init(mSetupPACURI,
                          mSetupPACData);
       nsRefPtr<PACLoadComplete> runnable = new PACLoadComplete(mPACMan);
       NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
       return NS_OK;
     }
     mPACMan->ProcessPendingQ();
     return NS_OK;
   }
 private:
   nsRefPtr<nsPACMan> mPACMan;
   bool      mCancel;
   nsresult  mCancelStatus;
   bool                 mSetupPAC;
   nsCString            mSetupPACData;
   nsCString            mSetupPACURI;
 };
 //-----------------------------------------------------------------------------
 PendingPACQuery::PendingPACQuery(nsPACMan *pacMan, nsIURI *uri,
                                  nsPACManCallback *callback,
                                  bool mainThreadResponse)
   : mPACMan(pacMan)
   , mCallback(callback)
   , mOnMainThreadOnly(mainThreadResponse)
 {
   uri->GetAsciiSpec(mSpec);
   uri->GetAsciiHost(mHost);
   uri->GetScheme(mScheme);
   uri->GetPort(&mPort);
 }
 void
 PendingPACQuery::Complete(nsresult status, const nsCString &pacString)
 {
   if (!mCallback)
     return;
   nsRefPtr<ExecuteCallback> runnable = new ExecuteCallback(mCallback, status);
   runnable->SetPACString(pacString);
   if (mOnMainThreadOnly)
     NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
   else
     runnable->Run();
 }
 void
 PendingPACQuery::UseAlternatePACFile(const nsCString &pacURL)
 {
   if (!mCallback)
     return;
   nsRefPtr<ExecuteCallback> runnable = new ExecuteCallback(mCallback, NS_OK);
   runnable->SetPACURL(pacURL);
   if (mOnMainThreadOnly)
     NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
   else
     runnable->Run();
 }
 NS_IMETHODIMP
 PendingPACQuery::Run()
 {
   NS_ABORT_IF_FALSE(!NS_IsMainThread(), "wrong thread");
   mPACMan->PostQuery(this);
   return NS_OK;
 }
 //-----------------------------------------------------------------------------
 nsPACMan::nsPACMan()
   : mLoadPending(false)
   , mShutdown(false)
   , mLoadFailureCount(0)
   , mInProgress(false)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "pacman must be created on main thread");
 }
 nsPACMan::~nsPACMan()
 {
   if (mPACThread) {
     if (NS_IsMainThread()) {
       mPACThread->Shutdown();
     }
     else {
       nsRefPtr<ShutdownThread> runnable = new ShutdownThread(mPACThread);
       NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
     }
   }
   NS_ASSERTION(mLoader == nullptr, "pac man not shutdown properly");
   NS_ASSERTION(mPendingQ.isEmpty(), "pac man not shutdown properly");
 }
 void
 nsPACMan::Shutdown()
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "pacman must be shutdown on main thread");
   if (mShutdown) {
     return;
   }
   mShutdown = true;
   CancelExistingLoad();
   PostCancelPendingQ(NS_ERROR_ABORT);
   nsRefPtr<WaitForThreadShutdown> runnable = new WaitForThreadShutdown(this);
   NS_DispatchToMainThread(runnable);
 }
 nsresult
 nsPACMan::AsyncGetProxyForChannel(nsIChannel *channel, nsPACManCallback *callback,
                                   bool mainThreadResponse)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
   if (mShutdown)
     return NS_ERROR_NOT_AVAILABLE;
   // Maybe Reload PAC
   if (!mPACURISpec.IsEmpty() && !mScheduledReload.IsNull() &&
       TimeStamp::Now() > mScheduledReload)
     LoadPACFromURI(EmptyCString());
   nsCOMPtr<nsIURI> uri;
   nsresult rv = channel->GetURI(getter_AddRefs(uri));
   if (NS_FAILED(rv))
     return rv;
   nsRefPtr<PendingPACQuery> query =
     new PendingPACQuery(this, uri, callback, mainThreadResponse);
   if (IsPACURI(uri)) {
     // deal with this directly instead of queueing it
     query->Complete(NS_OK, EmptyCString());
     return NS_OK;
   }
   return mPACThread->Dispatch(query, nsIEventTarget::DISPATCH_NORMAL);
 }
 nsresult
 nsPACMan::PostQuery(PendingPACQuery *query)
 {
   NS_ABORT_IF_FALSE(!NS_IsMainThread(), "wrong thread");
   if (mShutdown) {
     query->Complete(NS_ERROR_NOT_AVAILABLE, EmptyCString());
     return NS_OK;
   }
   // add a reference to the query while it is in the pending list
   nsRefPtr<PendingPACQuery> addref(query);
   mPendingQ.insertBack(addref.forget().take());
   ProcessPendingQ();
   return NS_OK;
 }
 nsresult
 nsPACMan::LoadPACFromURI(const nsCString &spec)
 {
   NS_ENSURE_STATE(!mShutdown);
   NS_ENSURE_ARG(!spec.IsEmpty() || !mPACURISpec.IsEmpty());
   nsCOMPtr<nsIStreamLoader> loader =
       do_CreateInstance(NS_STREAMLOADER_CONTRACTID);
   NS_ENSURE_STATE(loader);
   // Since we might get called from nsProtocolProxyService::Init, we need to
   // post an event back to the main thread before we try to use the IO service.
   //
   // But, we need to flag ourselves as loading, so that we queue up any PAC
   // queries the enter between now and when we actually load the PAC file.
   if (!mLoadPending) {
     nsCOMPtr<nsIRunnable> event =
       NS_NewRunnableMethod(this, &nsPACMan::StartLoading);
     nsresult rv;
     if (NS_FAILED(rv = NS_DispatchToCurrentThread(event)))
       return rv;
     mLoadPending = true;
   }
   CancelExistingLoad();
   mLoader = loader;
   if (!spec.IsEmpty()) {
     mPACURISpec = spec;
     mPACURIRedirectSpec.Truncate();
     mNormalPACURISpec.Truncate(); // set at load time
     mLoadFailureCount = 0;  // reset
   }
   // reset to Null
   mScheduledReload = TimeStamp();
   return NS_OK;
 }
 void
 nsPACMan::StartLoading()
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
   mLoadPending = false;
   // CancelExistingLoad was called...
   if (!mLoader) {
     PostCancelPendingQ(NS_ERROR_ABORT);
     return;
   }
   if (NS_SUCCEEDED(mLoader->Init(this))) {
     // Always hit the origin server when loading PAC.
     nsCOMPtr<nsIIOService> ios = do_GetIOService();
     if (ios) {
       nsCOMPtr<nsIChannel> channel;
       nsCOMPtr<nsIURI> pacURI;
       NS_NewURI(getter_AddRefs(pacURI), mPACURISpec);
       // NOTE: This results in GetProxyForURI being called
       if (pacURI) {
         pacURI->GetSpec(mNormalPACURISpec);
         ios->NewChannelFromURI(pacURI, getter_AddRefs(channel));
       }
       else {
         LOG(("nsPACMan::StartLoading Failed pacspec uri conversion %s\n",
              mPACURISpec.get()));
       }
       if (channel) {
         channel->SetLoadFlags(nsIRequest::LOAD_BYPASS_CACHE);
         channel->SetNotificationCallbacks(this);
         if (NS_SUCCEEDED(channel->AsyncOpen(mLoader, nullptr)))
           return;
       }
     }
   }
   CancelExistingLoad();
   PostCancelPendingQ(NS_ERROR_UNEXPECTED);
 }
 void
 nsPACMan::OnLoadFailure()
 {
   int32_t minInterval = 5;    // 5 seconds
   int32_t maxInterval = 300;  // 5 minutes
   nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
   if (prefs) {
     prefs->GetIntPref("network.proxy.autoconfig_retry_interval_min",
                       &minInterval);
     prefs->GetIntPref("network.proxy.autoconfig_retry_interval_max",
                       &maxInterval);
   }
   int32_t interval = minInterval << mLoadFailureCount++;  // seconds
   if (!interval || interval > maxInterval)
     interval = maxInterval;
   mScheduledReload = TimeStamp::Now() + TimeDuration::FromSeconds(interval);
   // while we wait for the retry queued members should try direct
   // even if that means fast failure.
   PostCancelPendingQ(NS_ERROR_NOT_AVAILABLE);
 }
 void
 nsPACMan::CancelExistingLoad()
 {
   if (mLoader) {
     nsCOMPtr<nsIRequest> request;
     mLoader->GetRequest(getter_AddRefs(request));
     if (request)
       request->Cancel(NS_ERROR_ABORT);
     mLoader = nullptr;
   }
 }
 void
 nsPACMan::PostProcessPendingQ()
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
   nsRefPtr<ExecutePACThreadAction> pending =
     new ExecutePACThreadAction(this);
   if (mPACThread)
     mPACThread->Dispatch(pending, nsIEventTarget::DISPATCH_NORMAL);
 }
 void
 nsPACMan::PostCancelPendingQ(nsresult status)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
   nsRefPtr<ExecutePACThreadAction> pending =
     new ExecutePACThreadAction(this);
   pending->CancelQueue(status);
   if (mPACThread)
     mPACThread->Dispatch(pending, nsIEventTarget::DISPATCH_NORMAL);
 }
 void
 nsPACMan::CancelPendingQ(nsresult status)
 {
   NS_ABORT_IF_FALSE(!NS_IsMainThread(), "wrong thread");
   nsRefPtr<PendingPACQuery> query;
   while (!mPendingQ.isEmpty()) {
     query = dont_AddRef(mPendingQ.popLast());
     query->Complete(status, EmptyCString());
   }
   if (mShutdown)
     mPAC.Shutdown();
 }
 void
 nsPACMan::ProcessPendingQ()
 {
   NS_ABORT_IF_FALSE(!NS_IsMainThread(), "wrong thread");
   while (ProcessPending());
   if (mShutdown) {
     mPAC.Shutdown();
   } else {
     // do GC while the thread has nothing pending
     mPAC.GC();
   }
 }
 // returns true if progress was made by shortening the queue
 bool
 nsPACMan::ProcessPending()
 {
   if (mPendingQ.isEmpty())
     return false;
   // queue during normal load, but if we are retrying a failed load then
   // fast fail the queries
   if (mInProgress || (IsLoading() && !mLoadFailureCount))
     return false;
   nsRefPtr<PendingPACQuery> query(dont_AddRef(mPendingQ.popFirst()));
   if (mShutdown || IsLoading()) {
     query->Complete(NS_ERROR_NOT_AVAILABLE, EmptyCString());
     return true;
   }
   nsAutoCString pacString;
   bool completed = false;
   mInProgress = true;
   nsAutoCString PACURI;
   // first we need to consider the system proxy changing the pac url
   if (mSystemProxySettings &&
       NS_SUCCEEDED(mSystemProxySettings->GetPACURI(PACURI)) &&
       !PACURI.IsEmpty() &&
       !PACURI.Equals(mPACURISpec)) {
     query->UseAlternatePACFile(PACURI);
     completed = true;
   }
   // now try the system proxy settings for this particular url if
   // PAC was not specified
   if (!completed && mSystemProxySettings && PACURI.IsEmpty() &&
       NS_SUCCEEDED(mSystemProxySettings->
                    GetProxyForURI(query->mSpec, query->mScheme,
                                   query->mHost, query->mPort,
                                   pacString))) {
     query->Complete(NS_OK, pacString);
     completed = true;
   }
   // the systemproxysettings didn't complete the resolution. try via PAC
   if (!completed) {
     nsresult status = mPAC.GetProxyForURI(query->mSpec, query->mHost, pacString);
     query->Complete(status, pacString);
   }
   mInProgress = false;
   return true;
 }
 NS_IMPL_ISUPPORTS(nsPACMan, nsIStreamLoaderObserver,
                   nsIInterfaceRequestor, nsIChannelEventSink)
 NS_IMETHODIMP
 nsPACMan::OnStreamComplete(nsIStreamLoader *loader,
                            nsISupports *context,
                            nsresult status,
                            uint32_t dataLen,
                            const uint8_t *data)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
   if (mLoader != loader) {
     // If this happens, then it means that LoadPACFromURI was called more
     // than once before the initial call completed.  In this case, status
     // should be NS_ERROR_ABORT, and if so, then we know that we can and
     // should delay any processing.
     if (status == NS_ERROR_ABORT)
       return NS_OK;
   }
   if (NS_SUCCEEDED(status) && HttpRequestSucceeded(loader)) {
     // Get the URI spec used to load this PAC script.
     nsAutoCString pacURI;
     {
       nsCOMPtr<nsIRequest> request;
       loader->GetRequest(getter_AddRefs(request));
       nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
       if (channel) {
         nsCOMPtr<nsIURI> uri;
         channel->GetURI(getter_AddRefs(uri));
         if (uri)
           uri->GetAsciiSpec(pacURI);
       }
     }
     // We assume that the PAC text is ASCII (or ISO-Latin-1).  We've had this
     // assumption forever, and some real-world PAC scripts actually have some
     // non-ASCII text in comment blocks (see bug 296163).
     const char *text = (const char *) data;
     // we have succeeded in loading the pac file using a bunch of interfaces that
     // are main thread only, unfortunately we have to initialize the instance of
     // the PAC evaluator (NS_PROXYAUTOCONFIG_CONTRACTID) on the pac thread, because
     // that is where it will be used.
     nsRefPtr<ExecutePACThreadAction> pending =
       new ExecutePACThreadAction(this);
     pending->SetupPAC(text, dataLen, pacURI);
     if (mPACThread)
       mPACThread->Dispatch(pending, nsIEventTarget::DISPATCH_NORMAL);
     // Even if the PAC file could not be parsed, we did succeed in loading the
     // data for it.
     mLoadFailureCount = 0;
   } else {
     // We were unable to load the PAC file (presumably because of a network
     // failure).  Try again a little later.
     OnLoadFailure();
   }
   if (NS_SUCCEEDED(status))
     PostProcessPendingQ();
   else
     PostCancelPendingQ(status);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsPACMan::GetInterface(const nsIID &iid, void **result)
 {
   // In case loading the PAC file requires authentication.
   if (iid.Equals(NS_GET_IID(nsIAuthPrompt))) {
     nsCOMPtr<nsIPromptFactory> promptFac = do_GetService("@mozilla.org/prompter;1");
     NS_ENSURE_TRUE(promptFac, NS_ERROR_FAILURE);
     return promptFac->GetPrompt(nullptr, iid, reinterpret_cast<void**>(result));
   }
   // In case loading the PAC file results in a redirect.
   if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) {
     NS_ADDREF_THIS();
     *result = static_cast<nsIChannelEventSink *>(this);
     return NS_OK;
   }
   return NS_ERROR_NO_INTERFACE;
 }
 NS_IMETHODIMP
 nsPACMan::AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel,
                                  uint32_t flags,
                                  nsIAsyncVerifyRedirectCallback *callback)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "wrong thread");
   nsresult rv = NS_OK;
   nsCOMPtr<nsIURI> pacURI;
   if (NS_FAILED((rv = newChannel->GetURI(getter_AddRefs(pacURI)))))
       return rv;
   rv = pacURI->GetSpec(mPACURIRedirectSpec);
   if (NS_FAILED(rv))
       return rv;
   LOG(("nsPACMan redirect from original %s to redirected %s\n",
        mPACURISpec.get(), mPACURIRedirectSpec.get()));
   // do not update mPACURISpec - that needs to stay as the
   // configured URI so that we can determine when the config changes.
   // However do track the most recent URI in the redirect change
   // as mPACURIRedirectSpec so that URI can be allowed to bypass
   // the proxy and actually fetch the pac file.
   callback->OnRedirectVerifyCallback(NS_OK);
   return NS_OK;
 }
 void
 nsPACMan::NamePACThread()
 {
   NS_ABORT_IF_FALSE(!NS_IsMainThread(), "wrong thread");
   PR_SetCurrentThreadName("Proxy Resolution");
 #ifdef MOZ_NUWA_PROCESS
   if (IsNuwaProcess()) {
     NS_ASSERTION(NuwaMarkCurrentThread != nullptr,
                  "NuwaMarkCurrentThread is undefined!");
     NuwaMarkCurrentThread(nullptr, nullptr);
   }
 #endif
 }
 nsresult
 nsPACMan::Init(nsISystemProxySettings *systemProxySettings)
 {
   mSystemProxySettings = systemProxySettings;
   nsresult rv = NS_NewThread(getter_AddRefs(mPACThread), nullptr);
   if (NS_FAILED(rv))
     return rv;
   nsCOMPtr<nsIRunnable> event = NS_NewRunnableMethod(this, &nsPACMan::NamePACThread);
   // don't check return value as it is not a big deal for this to fail.
   mPACThread->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL);
   return NS_OK;
 }
 namespace mozilla {
 namespace net {
 PRLogModuleInfo*
 GetProxyLog()
 {
     static PRLogModuleInfo *sLog;
     if (!sLog)
         sLog = PR_NewLogModule("proxy");
     return sLog;
 }
 }
 }

The Tor Browser / annotate

netwerk/base/src/nsPACMan.cpp@b8a032363ba2 (annotated)

netwerk/base/src/nsPACMan.cpp