2011-08-19 15:50:04 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2011-08-19 15:50:04 +00:00
|
|
|
|
|
|
|
#include "nsUrlClassifierProxies.h"
|
|
|
|
#include "nsUrlClassifierDBService.h"
|
|
|
|
|
2015-01-14 01:09:13 +00:00
|
|
|
#include "mozilla/SyncRunnable.h"
|
|
|
|
|
2012-11-01 22:09:22 +00:00
|
|
|
using namespace mozilla::safebrowsing;
|
2016-05-05 08:45:00 +00:00
|
|
|
using mozilla::NewRunnableMethod;
|
2012-11-01 22:09:22 +00:00
|
|
|
|
2011-08-19 15:50:04 +00:00
|
|
|
static nsresult
|
|
|
|
DispatchToWorkerThread(nsIRunnable* r)
|
|
|
|
{
|
|
|
|
nsIThread* t = nsUrlClassifierDBService::BackgroundThread();
|
|
|
|
if (!t)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
return t->Dispatch(r, NS_DISPATCH_NORMAL);
|
|
|
|
}
|
|
|
|
|
2016-08-11 03:15:24 +00:00
|
|
|
NS_IMPL_ISUPPORTS(UrlClassifierDBServiceWorkerProxy, nsIUrlClassifierDBService)
|
2011-08-19 15:50:04 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-07-22 19:30:30 +00:00
|
|
|
UrlClassifierDBServiceWorkerProxy::Lookup(nsIPrincipal* aPrincipal,
|
2014-03-20 21:25:35 +00:00
|
|
|
const nsACString& aTables,
|
2011-08-19 15:50:04 +00:00
|
|
|
nsIUrlClassifierCallback* aCB)
|
|
|
|
{
|
2014-03-20 21:25:35 +00:00
|
|
|
nsCOMPtr<nsIRunnable> r = new LookupRunnable(mTarget, aPrincipal, aTables,
|
|
|
|
aCB);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::LookupRunnable::Run()
|
|
|
|
{
|
2014-03-20 21:25:35 +00:00
|
|
|
(void) mTarget->Lookup(mPrincipal, mLookupTables, mCB);
|
2011-08-19 15:50:04 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::GetTables(nsIUrlClassifierCallback* aCB)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> 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,
|
2014-01-16 08:27:58 +00:00
|
|
|
const nsACString& aTables)
|
2011-08-19 15:50:04 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r = new BeginUpdateRunnable(mTarget, aUpdater,
|
2014-01-16 08:27:58 +00:00
|
|
|
aTables);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::BeginUpdateRunnable::Run()
|
|
|
|
{
|
2014-01-16 08:27:58 +00:00
|
|
|
mTarget->BeginUpdate(mUpdater, mTables);
|
2011-08-19 15:50:04 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-16 08:27:58 +00:00
|
|
|
UrlClassifierDBServiceWorkerProxy::BeginStream(const nsACString& aTable)
|
2011-08-19 15:50:04 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2014-01-16 08:27:58 +00:00
|
|
|
new BeginStreamRunnable(mTarget, aTable);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::BeginStreamRunnable::Run()
|
|
|
|
{
|
2014-01-16 08:27:58 +00:00
|
|
|
mTarget->BeginStream(mTable);
|
2011-08-19 15:50:04 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::UpdateStream(const nsACString& aUpdateChunk)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
|
|
|
new UpdateStreamRunnable(mTarget, aUpdateChunk);
|
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::UpdateStreamRunnable::Run()
|
|
|
|
{
|
|
|
|
mTarget->UpdateStream(mUpdateChunk);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::FinishStream()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::FinishStream",
|
|
|
|
mTarget,
|
2016-08-11 03:15:24 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::FinishStream);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
2015-01-14 01:09:13 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::DoLocalLookupRunnable::Run()
|
|
|
|
{
|
|
|
|
mTarget->DoLocalLookup(mSpec, mTables, mResults);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
UrlClassifierDBServiceWorkerProxy::DoLocalLookup(const nsACString& spec,
|
|
|
|
const nsACString& tables,
|
|
|
|
LookupResultArray* results)
|
|
|
|
|
|
|
|
{
|
|
|
|
// Run synchronously on background thread. NS_DISPATCH_SYNC does *not* do
|
|
|
|
// what we want -- it continues processing events on the main thread loop
|
|
|
|
// before the Dispatch returns.
|
|
|
|
nsCOMPtr<nsIRunnable> r = new DoLocalLookupRunnable(mTarget, spec, tables, results);
|
|
|
|
nsIThread* t = nsUrlClassifierDBService::BackgroundThread();
|
|
|
|
if (!t)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
mozilla::SyncRunnable::DispatchToThread(t, r);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-08-19 15:50:04 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::FinishUpdate()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::FinishUpdate",
|
|
|
|
mTarget,
|
2016-08-11 03:15:24 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::FinishUpdate);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::CancelUpdate()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::CancelUpdate",
|
|
|
|
mTarget,
|
2016-08-11 03:15:24 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::CancelUpdate);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::ResetDatabase()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::ResetDatabase",
|
|
|
|
mTarget,
|
2016-08-11 03:15:24 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::ResetDatabase);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
2016-08-11 00:17:39 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::ReloadDatabase()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::ReloadDatabase",
|
|
|
|
mTarget,
|
2016-08-15 22:04:43 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::ReloadDatabase);
|
2016-08-11 00:17:39 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
2017-05-17 02:32:33 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::ClearCache()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::ClearCache",
|
|
|
|
mTarget,
|
2017-05-17 02:32:33 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::ClearCache);
|
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
2016-08-11 03:15:24 +00:00
|
|
|
nsresult
|
2014-12-18 18:18:09 +00:00
|
|
|
UrlClassifierDBServiceWorkerProxy::OpenDb()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::OpenDb",
|
|
|
|
mTarget,
|
2016-08-11 03:15:24 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::OpenDb);
|
2014-12-18 18:18:09 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
2016-08-11 03:15:24 +00:00
|
|
|
nsresult
|
2011-08-19 15:50:04 +00:00
|
|
|
UrlClassifierDBServiceWorkerProxy::CloseDb()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2017-06-12 19:34:10 +00:00
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::CloseDb",
|
|
|
|
mTarget,
|
2016-08-11 03:15:24 +00:00
|
|
|
&nsUrlClassifierDBServiceWorker::CloseDb);
|
2011-08-19 15:50:04 +00:00
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
2017-10-20 02:18:59 +00:00
|
|
|
nsresult
|
|
|
|
UrlClassifierDBServiceWorkerProxy::PreShutdown()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
|
|
|
NewRunnableMethod("nsUrlClassifierDBServiceWorker::PreShutdown",
|
|
|
|
mTarget,
|
|
|
|
&nsUrlClassifierDBServiceWorker::PreShutdown);
|
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
2016-08-11 03:15:24 +00:00
|
|
|
nsresult
|
2012-08-15 07:04:19 +00:00
|
|
|
UrlClassifierDBServiceWorkerProxy::CacheCompletions(CacheResultArray * aEntries)
|
2011-08-19 15:50:04 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r = new CacheCompletionsRunnable(mTarget, aEntries);
|
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::CacheCompletionsRunnable::Run()
|
|
|
|
{
|
|
|
|
mTarget->CacheCompletions(mEntries);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-03-04 20:33:20 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::ClearLastResults()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r = new ClearLastResultsRunnable(mTarget);
|
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::ClearLastResultsRunnable::Run()
|
|
|
|
{
|
|
|
|
return mTarget->ClearLastResults();
|
|
|
|
}
|
|
|
|
|
2017-05-17 02:32:33 +00:00
|
|
|
nsresult
|
|
|
|
UrlClassifierDBServiceWorkerProxy::GetCacheInfo(const nsACString& aTable,
|
2017-10-18 01:11:26 +00:00
|
|
|
nsIUrlClassifierGetCacheCallback* aCallback)
|
2017-05-17 02:32:33 +00:00
|
|
|
{
|
2017-10-18 01:11:26 +00:00
|
|
|
nsCOMPtr<nsIRunnable> r = new GetCacheInfoRunnable(mTarget, aTable, aCallback);
|
|
|
|
return DispatchToWorkerThread(r);
|
|
|
|
}
|
2017-05-17 02:32:33 +00:00
|
|
|
|
2017-10-18 01:11:26 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierDBServiceWorkerProxy::GetCacheInfoRunnable::Run()
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(mCallback);
|
2017-05-17 02:32:33 +00:00
|
|
|
|
2017-10-18 01:11:26 +00:00
|
|
|
mTarget->GetCacheInfo(mTable, &mCache);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIRunnable> r = new GetCacheInfoCallbackRunnable(mCache, mCallback);
|
|
|
|
return NS_DispatchToMainThread(r);
|
2017-05-17 02:32:33 +00:00
|
|
|
}
|
|
|
|
|
2017-10-18 01:11:26 +00:00
|
|
|
|
2017-05-17 02:32:33 +00:00
|
|
|
NS_IMETHODIMP
|
2017-10-18 01:11:26 +00:00
|
|
|
UrlClassifierDBServiceWorkerProxy::GetCacheInfoCallbackRunnable::Run()
|
2017-05-17 02:32:33 +00:00
|
|
|
{
|
2017-10-18 01:11:26 +00:00
|
|
|
MOZ_ASSERT(NS_IsMainThread(), "Must be called on main thread");
|
|
|
|
MOZ_ASSERT(mCallback);
|
|
|
|
|
|
|
|
mCallback->OnGetCacheComplete(mCache);
|
|
|
|
NS_RELEASE(mCache);
|
|
|
|
|
|
|
|
return NS_OK;
|
2017-05-17 02:32:33 +00:00
|
|
|
}
|
|
|
|
|
2014-04-27 07:06:00 +00:00
|
|
|
NS_IMPL_ISUPPORTS(UrlClassifierLookupCallbackProxy,
|
|
|
|
nsIUrlClassifierLookupCallback)
|
2011-08-19 15:50:04 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierLookupCallbackProxy::LookupComplete
|
2012-08-15 07:04:19 +00:00
|
|
|
(LookupResultArray * aResults)
|
2011-08-19 15:50:04 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r = new LookupCompleteRunnable(mTarget, aResults);
|
|
|
|
return NS_DispatchToMainThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierLookupCallbackProxy::LookupCompleteRunnable::Run()
|
|
|
|
{
|
|
|
|
mTarget->LookupComplete(mResults);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-04-27 07:06:00 +00:00
|
|
|
NS_IMPL_ISUPPORTS(UrlClassifierCallbackProxy,
|
|
|
|
nsIUrlClassifierCallback)
|
2011-08-19 15:50:04 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierCallbackProxy::HandleEvent(const nsACString& aValue)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r = new HandleEventRunnable(mTarget, aValue);
|
|
|
|
return NS_DispatchToMainThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierCallbackProxy::HandleEventRunnable::Run()
|
|
|
|
{
|
|
|
|
mTarget->HandleEvent(mValue);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-04-27 07:06:00 +00:00
|
|
|
NS_IMPL_ISUPPORTS(UrlClassifierUpdateObserverProxy,
|
|
|
|
nsIUrlClassifierUpdateObserver)
|
2011-08-19 15:50:04 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierUpdateObserverProxy::UpdateUrlRequested
|
|
|
|
(const nsACString& aURL,
|
2014-01-16 08:27:58 +00:00
|
|
|
const nsACString& aTable)
|
2011-08-19 15:50:04 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
2014-01-16 08:27:58 +00:00
|
|
|
new UpdateUrlRequestedRunnable(mTarget, aURL, aTable);
|
2011-08-19 15:50:04 +00:00
|
|
|
return NS_DispatchToMainThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierUpdateObserverProxy::UpdateUrlRequestedRunnable::Run()
|
|
|
|
{
|
2014-01-16 08:27:58 +00:00
|
|
|
mTarget->UpdateUrlRequested(mURL, mTable);
|
2012-10-18 11:52:03 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-08-19 15:50:04 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierUpdateObserverProxy::StreamFinished(nsresult aStatus,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aDelay)
|
2011-08-19 15:50:04 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> 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<nsIRunnable> r =
|
|
|
|
new UpdateErrorRunnable(mTarget, aError);
|
|
|
|
return NS_DispatchToMainThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierUpdateObserverProxy::UpdateErrorRunnable::Run()
|
|
|
|
{
|
|
|
|
mTarget->UpdateError(mError);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
UrlClassifierUpdateObserverProxy::UpdateSuccess(uint32_t aRequestedTimeout)
|
2011-08-19 15:50:04 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRunnable> r =
|
|
|
|
new UpdateSuccessRunnable(mTarget, aRequestedTimeout);
|
|
|
|
return NS_DispatchToMainThread(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
UrlClassifierUpdateObserverProxy::UpdateSuccessRunnable::Run()
|
|
|
|
{
|
|
|
|
mTarget->UpdateSuccess(mRequestedTimeout);
|
|
|
|
return NS_OK;
|
|
|
|
}
|