From d6d1b6d9a4590ca5255b4fcf000fd2e1be13d75e Mon Sep 17 00:00:00 2001 From: Benjamin Smedberg Date: Fri, 19 Aug 2011 11:50:04 -0400 Subject: [PATCH] Bug 675221 part D - Fix up URL classifier to stop using XPCOM proxies, r=dcamp --HG-- extra : rebase_source : a482200a9095a9115ac8829af045a16fa2ba1b38 --- toolkit/components/url-classifier/Makefile.in | 1 + .../nsUrlClassifierDBService.cpp | 47 +-- .../url-classifier/nsUrlClassifierDBService.h | 8 +- .../url-classifier/nsUrlClassifierProxies.cpp | 307 +++++++++++++++++ .../url-classifier/nsUrlClassifierProxies.h | 315 ++++++++++++++++++ 5 files changed, 646 insertions(+), 32 deletions(-) create mode 100644 toolkit/components/url-classifier/nsUrlClassifierProxies.cpp create mode 100644 toolkit/components/url-classifier/nsUrlClassifierProxies.h diff --git a/toolkit/components/url-classifier/Makefile.in b/toolkit/components/url-classifier/Makefile.in index 52aab01d254..9dfe0e86437 100644 --- a/toolkit/components/url-classifier/Makefile.in +++ b/toolkit/components/url-classifier/Makefile.in @@ -61,6 +61,7 @@ CPPSRCS = \ nsUrlClassifierDBService.cpp \ nsUrlClassifierStreamUpdater.cpp \ nsUrlClassifierUtils.cpp \ + nsUrlClassifierProxies.cpp \ $(NULL) LOCAL_INCLUDES = \ diff --git a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp index 771c07d643e..ec45accb8e6 100644 --- a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp +++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp @@ -59,12 +59,12 @@ #include "nsIPrefBranch2.h" #include "nsIPrefService.h" #include "nsIProperties.h" -#include "nsIProxyObjectManager.h" #include "nsToolkitCompsCID.h" #include "nsIUrlClassifierUtils.h" #include "nsIRandomGenerator.h" #include "nsUrlClassifierDBService.h" #include "nsUrlClassifierUtils.h" +#include "nsUrlClassifierProxies.h" #include "nsURILoader.h" #include "nsString.h" #include "nsReadableUtils.h" @@ -181,8 +181,7 @@ class nsUrlClassifierDBServiceWorker; // Singleton instance. static nsUrlClassifierDBService* sUrlClassifierDBService; -// Thread that we do the updates on. -static nsIThread* gDbBackgroundThread = nsnull; +nsIThread* nsUrlClassifierDBService::gDbBackgroundThread = nsnull; // Once we've committed to shutting down, don't do work in the background // thread. @@ -3920,12 +3919,7 @@ nsUrlClassifierDBService::Init() } // Proxy for calling the worker on the background thread - rv = NS_GetProxyForObject(gDbBackgroundThread, - NS_GET_IID(nsIUrlClassifierDBServiceWorker), - mWorker, - NS_PROXY_ASYNC, - getter_AddRefs(mWorkerProxy)); - NS_ENSURE_SUCCESS(rv, rv); + mWorkerProxy = new UrlClassifierDBServiceWorkerProxy(mWorker); mCompleters.Init(); @@ -4038,14 +4032,8 @@ nsUrlClassifierDBService::LookupURI(nsIURI* uri, if (!callback) return NS_ERROR_OUT_OF_MEMORY; - nsCOMPtr proxyCallback; - // The proxy callback uses the current thread. - rv = NS_GetProxyForObject(NS_PROXY_TO_CURRENT_THREAD, - NS_GET_IID(nsIUrlClassifierLookupCallback), - callback, - NS_PROXY_ASYNC, - getter_AddRefs(proxyCallback)); - NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr proxyCallback = + new UrlClassifierLookupCallbackProxy(callback); // Queue this lookup and call the lookup function to flush the queue if // necessary. @@ -4062,13 +4050,8 @@ nsUrlClassifierDBService::GetTables(nsIUrlClassifierCallback* c) nsresult rv; // The proxy callback uses the current thread. - nsCOMPtr proxyCallback; - rv = NS_GetProxyForObject(NS_PROXY_TO_CURRENT_THREAD, - NS_GET_IID(nsIUrlClassifierCallback), - c, - NS_PROXY_ASYNC, - getter_AddRefs(proxyCallback)); - NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr proxyCallback = + new UrlClassifierCallbackProxy(c); return mWorkerProxy->GetTables(proxyCallback); } @@ -4103,13 +4086,8 @@ nsUrlClassifierDBService::BeginUpdate(nsIUrlClassifierUpdateObserver *observer, nsresult rv; // The proxy observer uses the current thread - nsCOMPtr proxyObserver; - rv = NS_GetProxyForObject(NS_PROXY_TO_CURRENT_THREAD, - NS_GET_IID(nsIUrlClassifierUpdateObserver), - observer, - NS_PROXY_ASYNC, - getter_AddRefs(proxyObserver)); - NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr proxyObserver = + new UrlClassifierUpdateObserverProxy(observer); return mWorkerProxy->BeginUpdate(proxyObserver, updateTables, clientKey); } @@ -4284,3 +4262,10 @@ nsUrlClassifierDBService::Shutdown() return NS_OK; } + +nsIThread* +nsUrlClassifierDBService::BackgroundThread() +{ + return gDbBackgroundThread; +} + diff --git a/toolkit/components/url-classifier/nsUrlClassifierDBService.h b/toolkit/components/url-classifier/nsUrlClassifierDBService.h index afd6a1f677f..55ed78898f8 100644 --- a/toolkit/components/url-classifier/nsUrlClassifierDBService.h +++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.h @@ -60,6 +60,7 @@ #define COMPLETE_LENGTH 32 class nsUrlClassifierDBServiceWorker; +class nsIThread; // This is a proxy class that just creates a background thread and delagates // calls to the background thread. @@ -86,6 +87,8 @@ public: nsIUrlClassifierHashCompleter** completer); nsresult CacheCompletions(nsTArray *results); + static nsIThread* BackgroundThread(); + private: // No subclassing ~nsUrlClassifierDBService(); @@ -100,7 +103,7 @@ private: nsresult Shutdown(); nsCOMPtr mWorker; - nsCOMPtr mWorkerProxy; + nsCOMPtr mWorkerProxy; nsInterfaceHashtable mCompleters; @@ -120,6 +123,9 @@ private: // The list of tables that can use the default hash completer object. nsTArray mGethashWhitelist; + + // Thread that we do the updates on. + static nsIThread* gDbBackgroundThread; }; NS_DEFINE_STATIC_IID_ACCESSOR(nsUrlClassifierDBService, NS_URLCLASSIFIERDBSERVICE_CID) diff --git a/toolkit/components/url-classifier/nsUrlClassifierProxies.cpp b/toolkit/components/url-classifier/nsUrlClassifierProxies.cpp new file mode 100644 index 00000000000..dabcf59ac38 --- /dev/null +++ b/toolkit/components/url-classifier/nsUrlClassifierProxies.cpp @@ -0,0 +1,307 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla Firefox. + * + * The Initial Developer of the Original Code is + * the Mozilla Foundation . + * Portions created by the Initial Developer are Copyright (C) 2011 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include "nsUrlClassifierProxies.h" +#include "nsUrlClassifierDBService.h" + +static nsresult +DispatchToWorkerThread(nsIRunnable* r) +{ + nsIThread* t = nsUrlClassifierDBService::BackgroundThread(); + if (!t) + return NS_ERROR_FAILURE; + + return t->Dispatch(r, NS_DISPATCH_NORMAL); +} + +NS_IMPL_THREADSAFE_ISUPPORTS1(UrlClassifierDBServiceWorkerProxy, + nsIUrlClassifierDBServiceWorker) + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::Lookup(const nsACString& aSpec, + nsIUrlClassifierCallback* aCB) +{ + nsCOMPtr r = new LookupRunnable(mTarget, aSpec, aCB); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::LookupRunnable::Run() +{ + mTarget->Lookup(mSpec, mCB); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::GetTables(nsIUrlClassifierCallback* aCB) +{ + nsCOMPtr r = new GetTablesRunnable(mTarget, aCB); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::GetTablesRunnable::Run() +{ + mTarget->GetTables(mCB); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::SetHashCompleter + (const nsACString&, nsIUrlClassifierHashCompleter*) +{ + NS_NOTREACHED("This method should not be called!"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::BeginUpdate + (nsIUrlClassifierUpdateObserver* aUpdater, + const nsACString& aTables, + const nsACString& aClientKey) +{ + nsCOMPtr r = new BeginUpdateRunnable(mTarget, aUpdater, + aTables, aClientKey); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::BeginUpdateRunnable::Run() +{ + mTarget->BeginUpdate(mUpdater, mTables, mClientKey); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::BeginStream(const nsACString& aTable, + const nsACString& aServerMAC) +{ + nsCOMPtr r = + new BeginStreamRunnable(mTarget, aTable, aServerMAC); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::BeginStreamRunnable::Run() +{ + mTarget->BeginStream(mTable, mServerMAC); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::UpdateStream(const nsACString& aUpdateChunk) +{ + nsCOMPtr r = + new UpdateStreamRunnable(mTarget, aUpdateChunk); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::UpdateStreamRunnable::Run() +{ + mTarget->UpdateStream(mUpdateChunk); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::FinishStream() +{ + nsCOMPtr r = + NS_NewRunnableMethod(mTarget, + &nsIUrlClassifierDBServiceWorker::FinishStream); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::FinishUpdate() +{ + nsCOMPtr r = + NS_NewRunnableMethod(mTarget, + &nsIUrlClassifierDBServiceWorker::FinishUpdate); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::CancelUpdate() +{ + nsCOMPtr r = + NS_NewRunnableMethod(mTarget, + &nsIUrlClassifierDBServiceWorker::CancelUpdate); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::ResetDatabase() +{ + nsCOMPtr r = + NS_NewRunnableMethod(mTarget, + &nsIUrlClassifierDBServiceWorker::ResetDatabase); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::CloseDb() +{ + nsCOMPtr r = + NS_NewRunnableMethod(mTarget, + &nsIUrlClassifierDBServiceWorker::CloseDb); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::CacheCompletions(nsTArray* aEntries) +{ + nsCOMPtr r = new CacheCompletionsRunnable(mTarget, aEntries); + return DispatchToWorkerThread(r); +} + +NS_IMETHODIMP +UrlClassifierDBServiceWorkerProxy::CacheCompletionsRunnable::Run() +{ + mTarget->CacheCompletions(mEntries); + return NS_OK; +} + +NS_IMPL_THREADSAFE_ISUPPORTS1(UrlClassifierLookupCallbackProxy, + nsIUrlClassifierLookupCallback) + +NS_IMETHODIMP +UrlClassifierLookupCallbackProxy::LookupComplete + (nsTArray* aResults) +{ + nsCOMPtr r = new LookupCompleteRunnable(mTarget, aResults); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +UrlClassifierLookupCallbackProxy::LookupCompleteRunnable::Run() +{ + mTarget->LookupComplete(mResults); + return NS_OK; +} + +NS_IMPL_THREADSAFE_ISUPPORTS1(UrlClassifierCallbackProxy, + nsIUrlClassifierCallback) + +NS_IMETHODIMP +UrlClassifierCallbackProxy::HandleEvent(const nsACString& aValue) +{ + nsCOMPtr r = new HandleEventRunnable(mTarget, aValue); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +UrlClassifierCallbackProxy::HandleEventRunnable::Run() +{ + mTarget->HandleEvent(mValue); + return NS_OK; +} + +NS_IMPL_THREADSAFE_ISUPPORTS1(UrlClassifierUpdateObserverProxy, + nsIUrlClassifierUpdateObserver) + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::UpdateUrlRequested + (const nsACString& aURL, + const nsACString& aTable, + const nsACString& aServerMAC) +{ + nsCOMPtr r = + new UpdateUrlRequestedRunnable(mTarget, aURL, aTable, aServerMAC); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::UpdateUrlRequestedRunnable::Run() +{ + mTarget->UpdateUrlRequested(mURL, mTable, mServerMAC); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::RekeyRequested() +{ + nsCOMPtr r = + NS_NewRunnableMethod(mTarget, &nsIUrlClassifierUpdateObserver::RekeyRequested); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::StreamFinished(nsresult aStatus, + PRUint32 aDelay) +{ + nsCOMPtr r = + new StreamFinishedRunnable(mTarget, aStatus, aDelay); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::StreamFinishedRunnable::Run() +{ + mTarget->StreamFinished(mStatus, mDelay); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::UpdateError(nsresult aError) +{ + nsCOMPtr r = + new UpdateErrorRunnable(mTarget, aError); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::UpdateErrorRunnable::Run() +{ + mTarget->UpdateError(mError); + return NS_OK; +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::UpdateSuccess(PRUint32 aRequestedTimeout) +{ + nsCOMPtr r = + new UpdateSuccessRunnable(mTarget, aRequestedTimeout); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +UrlClassifierUpdateObserverProxy::UpdateSuccessRunnable::Run() +{ + mTarget->UpdateSuccess(mRequestedTimeout); + return NS_OK; +} diff --git a/toolkit/components/url-classifier/nsUrlClassifierProxies.h b/toolkit/components/url-classifier/nsUrlClassifierProxies.h new file mode 100644 index 00000000000..843f43a2673 --- /dev/null +++ b/toolkit/components/url-classifier/nsUrlClassifierProxies.h @@ -0,0 +1,315 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla Firefox. + * + * The Initial Developer of the Original Code is + * the Mozilla Foundation . + * Portions created by the Initial Developer are Copyright (C) 2011 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nsUrlClassifierProxies_h +#define nsUrlClassifierProxies_h + +#include "nsIUrlClassifierDBService.h" +#include "nsThreadUtils.h" + +/** + * Thread proxy from the main thread to the worker thread. + */ +class UrlClassifierDBServiceWorkerProxy : + public nsIUrlClassifierDBServiceWorker +{ +public: + UrlClassifierDBServiceWorkerProxy(nsIUrlClassifierDBServiceWorker* aTarget) + : mTarget(aTarget) + { } + + NS_DECL_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERDBSERVICE + NS_DECL_NSIURLCLASSIFIERDBSERVICEWORKER + + class LookupRunnable : public nsRunnable + { + public: + LookupRunnable(nsIUrlClassifierDBServiceWorker* aTarget, + const nsACString& aSpec, + nsIUrlClassifierCallback* aCB) + : mTarget(aTarget) + , mSpec(aSpec) + , mCB(aCB) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsCString mSpec; + nsCOMPtr mCB; + }; + + class GetTablesRunnable : public nsRunnable + { + public: + GetTablesRunnable(nsIUrlClassifierDBServiceWorker* aTarget, + nsIUrlClassifierCallback* aCB) + : mTarget(aTarget) + , mCB(aCB) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsCOMPtr mCB; + }; + + class BeginUpdateRunnable : public nsRunnable + { + public: + BeginUpdateRunnable(nsIUrlClassifierDBServiceWorker* aTarget, + nsIUrlClassifierUpdateObserver* aUpdater, + const nsACString& aTables, + const nsACString& aClientKey) + : mTarget(aTarget) + , mUpdater(aUpdater) + , mTables(aTables) + , mClientKey(aClientKey) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsCOMPtr mUpdater; + nsCString mTables, mClientKey; + }; + + class BeginStreamRunnable : public nsRunnable + { + public: + BeginStreamRunnable(nsIUrlClassifierDBServiceWorker* aTarget, + const nsACString& aTable, + const nsACString& aServerMAC) + : mTarget(aTarget) + , mTable(aTable) + , mServerMAC(aServerMAC) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsCString mTable, mServerMAC; + }; + + class UpdateStreamRunnable : public nsRunnable + { + public: + UpdateStreamRunnable(nsIUrlClassifierDBServiceWorker* aTarget, + const nsACString& aUpdateChunk) + : mTarget(aTarget) + , mUpdateChunk(aUpdateChunk) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsCString mUpdateChunk; + }; + + class CacheCompletionsRunnable : public nsRunnable + { + public: + CacheCompletionsRunnable(nsIUrlClassifierDBServiceWorker* aTarget, + nsTArray* aEntries) + : mTarget(aTarget) + , mEntries(aEntries) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsTArray* mEntries; + }; + +private: + nsCOMPtr mTarget; +}; + +// The remaining classes here are all proxies to the main thread + +class UrlClassifierLookupCallbackProxy : public nsIUrlClassifierLookupCallback +{ +public: + UrlClassifierLookupCallbackProxy(nsIUrlClassifierLookupCallback* aTarget) + : mTarget(aTarget) + { } + + NS_DECL_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERLOOKUPCALLBACK + + class LookupCompleteRunnable : public nsRunnable + { + public: + LookupCompleteRunnable(nsIUrlClassifierLookupCallback* aTarget, + nsTArray* aResults) + : mTarget(aTarget) + , mResults(aResults) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsTArray* mResults; + }; + +private: + nsCOMPtr mTarget; +}; + +class UrlClassifierCallbackProxy : public nsIUrlClassifierCallback +{ +public: + UrlClassifierCallbackProxy(nsIUrlClassifierCallback* aTarget) + : mTarget(aTarget) + { } + + NS_DECL_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERCALLBACK + + class HandleEventRunnable : public nsRunnable + { + public: + HandleEventRunnable(nsIUrlClassifierCallback* aTarget, + const nsACString& aValue) + : mTarget(aTarget) + , mValue(aValue) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsCString mValue; + }; + +private: + nsCOMPtr mTarget; +}; + +class UrlClassifierUpdateObserverProxy : public nsIUrlClassifierUpdateObserver +{ +public: + UrlClassifierUpdateObserverProxy(nsIUrlClassifierUpdateObserver* aTarget) + : mTarget(aTarget) + { } + + NS_DECL_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERUPDATEOBSERVER + + class UpdateUrlRequestedRunnable : public nsRunnable + { + public: + UpdateUrlRequestedRunnable(nsIUrlClassifierUpdateObserver* aTarget, + const nsACString& aURL, + const nsACString& aTable, + const nsACString& aServerMAC) + : mTarget(aTarget) + , mURL(aURL) + , mTable(aTable) + , mServerMAC(aServerMAC) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsCString mURL, mTable, mServerMAC; + }; + + class StreamFinishedRunnable : public nsRunnable + { + public: + StreamFinishedRunnable(nsIUrlClassifierUpdateObserver* aTarget, + nsresult aStatus, PRUint32 aDelay) + : mTarget(aTarget) + , mStatus(aStatus) + , mDelay(aDelay) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsresult mStatus; + PRUint32 mDelay; + }; + + class UpdateErrorRunnable : public nsRunnable + { + public: + UpdateErrorRunnable(nsIUrlClassifierUpdateObserver* aTarget, + nsresult aError) + : mTarget(aTarget) + , mError(aError) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + nsresult mError; + }; + + class UpdateSuccessRunnable : public nsRunnable + { + public: + UpdateSuccessRunnable(nsIUrlClassifierUpdateObserver* aTarget, + PRUint32 aRequestedTimeout) + : mTarget(aTarget) + , mRequestedTimeout(aRequestedTimeout) + { } + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr mTarget; + PRUint32 mRequestedTimeout; + }; + +private: + nsCOMPtr mTarget; +}; + +#endif // nsUrlClassifierProxies_h