dom/workers/URL.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "URL.h"
   7 #include "File.h"
   8
   9 #include "WorkerPrivate.h"
  10 #include "nsThreadUtils.h"
  11
  12 #include "nsPIDOMWindow.h"
  13 #include "nsGlobalWindow.h"
  14 #include "nsHostObjectProtocolHandler.h"
  15 #include "nsServiceManagerUtils.h"
  16
  17 #include "nsIDocument.h"
  18 #include "nsIDOMFile.h"
  19
  20 #include "mozilla/dom/URL.h"
  21 #include "mozilla/dom/URLBinding.h"
  22 #include "nsIIOService.h"
  23 #include "nsNetCID.h"
  24
  25 BEGIN_WORKERS_NAMESPACE
  26 using mozilla::dom::GlobalObject;
  27
  28 class URLProxy MOZ_FINAL
  29 {
  30 public:
  31   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(URLProxy)
  32
  33   URLProxy(mozilla::dom::URL* aURL)
  34     : mURL(aURL)
  35   {
  36     AssertIsOnMainThread();
  37   }
  38
  39   ~URLProxy()
  40   {
  41      MOZ_ASSERT(!mURL);
  42   }
  43
  44   mozilla::dom::URL* URL()
  45   {
  46     return mURL;
  47   }
  48
  49   nsIURI* URI()
  50   {
  51     return mURL->GetURI();
  52   }
  53
  54   void ReleaseURI()
  55   {
  56     AssertIsOnMainThread();
  57     mURL = nullptr;
  58   }
  59
  60 private:
  61   nsRefPtr<mozilla::dom::URL> mURL;
  62 };
  63
  64 // Base class for the URL runnable objects.
  65 class URLRunnable : public nsRunnable
  66 {
  67 protected:
  68   WorkerPrivate* mWorkerPrivate;
  69   uint32_t mSyncQueueKey;
  70
  71 private:
  72   class ResponseRunnable : public WorkerSyncRunnable
  73   {
  74     uint32_t mSyncQueueKey;
  75
  76   public:
  77     ResponseRunnable(WorkerPrivate* aWorkerPrivate,
  78                      uint32_t aSyncQueueKey)
  79     : WorkerSyncRunnable(aWorkerPrivate, aSyncQueueKey, false),
  80       mSyncQueueKey(aSyncQueueKey)
  81     {
  82       NS_ASSERTION(aWorkerPrivate, "Don't hand me a null WorkerPrivate!");
  83     }
  84
  85     bool
  86     WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
  87     {
  88       aWorkerPrivate->StopSyncLoop(mSyncQueueKey, true);
  89       return true;
  90     }
  91
  92     bool
  93     PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
  94     {
  95       AssertIsOnMainThread();
  96       return true;
  97     }
  98
  99     void
 100     PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
 101                  bool aDispatchResult)
 102     {
 103       AssertIsOnMainThread();
 104     }
 105   };
 106
 107 protected:
 108   URLRunnable(WorkerPrivate* aWorkerPrivate)
 109   : mWorkerPrivate(aWorkerPrivate)
 110   {
 111     mWorkerPrivate->AssertIsOnWorkerThread();
 112   }
 113
 114 public:
 115   bool
 116   Dispatch(JSContext* aCx)
 117   {
 118     mWorkerPrivate->AssertIsOnWorkerThread();
 119     AutoSyncLoopHolder syncLoop(mWorkerPrivate);
 120     mSyncQueueKey = syncLoop.SyncQueueKey();
 121
 122     if (NS_FAILED(NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL))) {
 123       JS_ReportError(aCx, "Failed to dispatch to main thread!");
 124       return false;
 125     }
 126
 127     return syncLoop.RunAndForget(aCx);
 128   }
 129
 130 private:
 131   NS_IMETHOD Run()
 132   {
 133     AssertIsOnMainThread();
 134
 135     MainThreadRun();
 136
 137     nsRefPtr<ResponseRunnable> response =
 138       new ResponseRunnable(mWorkerPrivate, mSyncQueueKey);
 139     if (!response->Dispatch(nullptr)) {
 140       NS_WARNING("Failed to dispatch response!");
 141     }
 142
 143     return NS_OK;
 144   }
 145
 146 protected:
 147   virtual void
 148   MainThreadRun() = 0;
 149 };
 150
 151 // This class creates an URL from a DOM Blob on the main thread.
 152 class CreateURLRunnable : public URLRunnable
 153 {
 154 private:
 155   nsIDOMBlob* mBlob;
 156   nsString& mURL;
 157
 158 public:
 159   CreateURLRunnable(WorkerPrivate* aWorkerPrivate, nsIDOMBlob* aBlob,
 160                     const mozilla::dom::objectURLOptions& aOptions,
 161                     nsString& aURL)
 162   : URLRunnable(aWorkerPrivate),
 163     mBlob(aBlob),
 164     mURL(aURL)
 165   {
 166     MOZ_ASSERT(aBlob);
 167   }
 168
 169   void
 170   MainThreadRun()
 171   {
 172     AssertIsOnMainThread();
 173
 174     nsCOMPtr<nsIPrincipal> principal;
 175     nsIDocument* doc = nullptr;
 176
 177     nsCOMPtr<nsPIDOMWindow> window = mWorkerPrivate->GetWindow();
 178     if (window) {
 179       doc = window->GetExtantDoc();
 180       if (!doc) {
 181         SetDOMStringToNull(mURL);
 182         return;
 183       }
 184
 185       principal = doc->NodePrincipal();
 186     } else {
 187       MOZ_ASSERT_IF(!mWorkerPrivate->GetParent(), mWorkerPrivate->IsChromeWorker());
 188       principal = mWorkerPrivate->GetPrincipal();
 189     }
 190
 191     nsCString url;
 192     nsresult rv = nsHostObjectProtocolHandler::AddDataEntry(
 193         NS_LITERAL_CSTRING(BLOBURI_SCHEME),
 194         mBlob, principal, url);
 195
 196     if (NS_FAILED(rv)) {
 197       NS_WARNING("Failed to add data entry for the blob!");
 198       SetDOMStringToNull(mURL);
 199       return;
 200     }
 201
 202     if (doc) {
 203       doc->RegisterHostObjectUri(url);
 204     } else {
 205       mWorkerPrivate->RegisterHostObjectURI(url);
 206     }
 207
 208     mURL = NS_ConvertUTF8toUTF16(url);
 209   }
 210 };
 211
 212 // This class revokes an URL on the main thread.
 213 class RevokeURLRunnable : public URLRunnable
 214 {
 215 private:
 216   const nsString mURL;
 217
 218 public:
 219   RevokeURLRunnable(WorkerPrivate* aWorkerPrivate,
 220                     const nsAString& aURL)
 221   : URLRunnable(aWorkerPrivate),
 222     mURL(aURL)
 223   {}
 224
 225   void
 226   MainThreadRun()
 227   {
 228     AssertIsOnMainThread();
 229
 230     nsCOMPtr<nsIPrincipal> principal;
 231     nsIDocument* doc = nullptr;
 232
 233     nsCOMPtr<nsPIDOMWindow> window = mWorkerPrivate->GetWindow();
 234     if (window) {
 235       doc = window->GetExtantDoc();
 236       if (!doc) {
 237         return;
 238       }
 239
 240       principal = doc->NodePrincipal();
 241     } else {
 242       MOZ_ASSERT_IF(!mWorkerPrivate->GetParent(), mWorkerPrivate->IsChromeWorker());
 243       principal = mWorkerPrivate->GetPrincipal();
 244     }
 245
 246     NS_ConvertUTF16toUTF8 url(mURL);
 247
 248     nsIPrincipal* urlPrincipal =
 249       nsHostObjectProtocolHandler::GetDataEntryPrincipal(url);
 250
 251     bool subsumes;
 252     if (urlPrincipal &&
 253         NS_SUCCEEDED(principal->Subsumes(urlPrincipal, &subsumes)) &&
 254         subsumes) {
 255       if (doc) {
 256         doc->UnregisterHostObjectUri(url);
 257       }
 258
 259       nsHostObjectProtocolHandler::RemoveDataEntry(url);
 260     }
 261
 262     if (!window) {
 263       mWorkerPrivate->UnregisterHostObjectURI(url);
 264     }
 265   }
 266 };
 267
 268 // This class creates a URL object on the main thread.
 269 class ConstructorRunnable : public URLRunnable
 270 {
 271 private:
 272   const nsString mURL;
 273
 274   const nsString mBase;
 275   nsRefPtr<URLProxy> mBaseProxy;
 276   mozilla::ErrorResult& mRv;
 277
 278   nsRefPtr<URLProxy> mRetval;
 279
 280 public:
 281   ConstructorRunnable(WorkerPrivate* aWorkerPrivate,
 282                       const nsAString& aURL, const nsAString& aBase,
 283                       mozilla::ErrorResult& aRv)
 284   : URLRunnable(aWorkerPrivate)
 285   , mURL(aURL)
 286   , mBase(aBase)
 287   , mRv(aRv)
 288   {
 289     mWorkerPrivate->AssertIsOnWorkerThread();
 290   }
 291
 292   ConstructorRunnable(WorkerPrivate* aWorkerPrivate,
 293                       const nsAString& aURL, URLProxy* aBaseProxy,
 294                       mozilla::ErrorResult& aRv)
 295   : URLRunnable(aWorkerPrivate)
 296   , mURL(aURL)
 297   , mBaseProxy(aBaseProxy)
 298   , mRv(aRv)
 299   {
 300     mWorkerPrivate->AssertIsOnWorkerThread();
 301   }
 302
 303   void
 304   MainThreadRun()
 305   {
 306     AssertIsOnMainThread();
 307
 308     nsresult rv;
 309     nsCOMPtr<nsIIOService> ioService(do_GetService(NS_IOSERVICE_CONTRACTID, &rv));
 310     if (NS_FAILED(rv)) {
 311       mRv.Throw(rv);
 312       return;
 313     }
 314
 315     nsCOMPtr<nsIURI> baseURL;
 316
 317     if (!mBaseProxy) {
 318       rv = ioService->NewURI(NS_ConvertUTF16toUTF8(mBase), nullptr, nullptr,
 319                              getter_AddRefs(baseURL));
 320       if (NS_FAILED(rv)) {
 321         mRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
 322         return;
 323       }
 324     } else {
 325       baseURL = mBaseProxy->URI();
 326     }
 327
 328     nsCOMPtr<nsIURI> url;
 329     rv = ioService->NewURI(NS_ConvertUTF16toUTF8(mURL), nullptr, baseURL,
 330                            getter_AddRefs(url));
 331     if (NS_FAILED(rv)) {
 332       mRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
 333       return;
 334     }
 335
 336     mRetval = new URLProxy(new mozilla::dom::URL(url));
 337   }
 338
 339   URLProxy*
 340   GetURLProxy()
 341   {
 342     return mRetval;
 343   }
 344 };
 345
 346 class TeardownRunnable : public nsRunnable
 347 {
 348 public:
 349   TeardownRunnable(URLProxy* aURLProxy)
 350     : mURLProxy(aURLProxy)
 351   {
 352   }
 353
 354   NS_IMETHOD Run()
 355   {
 356     AssertIsOnMainThread();
 357
 358     mURLProxy->ReleaseURI();
 359     mURLProxy = nullptr;
 360
 361     return NS_OK;
 362   }
 363
 364 private:
 365   nsRefPtr<URLProxy> mURLProxy;
 366 };
 367
 368 // This class is the generic getter for any URL property.
 369 class GetterRunnable : public URLRunnable
 370 {
 371 public:
 372   enum GetterType {
 373     GetterHref,
 374     GetterOrigin,
 375     GetterProtocol,
 376     GetterUsername,
 377     GetterPassword,
 378     GetterHost,
 379     GetterHostname,
 380     GetterPort,
 381     GetterPathname,
 382     GetterSearch,
 383     GetterHash,
 384   };
 385
 386   GetterRunnable(WorkerPrivate* aWorkerPrivate,
 387                  GetterType aType, nsString& aValue,
 388                  URLProxy* aURLProxy)
 389   : URLRunnable(aWorkerPrivate)
 390   , mValue(aValue)
 391   , mType(aType)
 392   , mURLProxy(aURLProxy)
 393   {
 394     mWorkerPrivate->AssertIsOnWorkerThread();
 395   }
 396
 397   void
 398   MainThreadRun()
 399   {
 400     AssertIsOnMainThread();
 401
 402     switch (mType) {
 403       case GetterHref:
 404         mURLProxy->URL()->GetHref(mValue);
 405         break;
 406
 407       case GetterOrigin:
 408         mURLProxy->URL()->GetOrigin(mValue);
 409         break;
 410
 411       case GetterProtocol:
 412         mURLProxy->URL()->GetProtocol(mValue);
 413         break;
 414
 415       case GetterUsername:
 416         mURLProxy->URL()->GetUsername(mValue);
 417         break;
 418
 419       case GetterPassword:
 420         mURLProxy->URL()->GetPassword(mValue);
 421         break;
 422
 423       case GetterHost:
 424         mURLProxy->URL()->GetHost(mValue);
 425         break;
 426
 427       case GetterHostname:
 428         mURLProxy->URL()->GetHostname(mValue);
 429         break;
 430
 431       case GetterPort:
 432         mURLProxy->URL()->GetPort(mValue);
 433         break;
 434
 435       case GetterPathname:
 436         mURLProxy->URL()->GetPathname(mValue);
 437         break;
 438
 439       case GetterSearch:
 440         mURLProxy->URL()->GetSearch(mValue);
 441         break;
 442
 443       case GetterHash:
 444         mURLProxy->URL()->GetHash(mValue);
 445         break;
 446     }
 447   }
 448
 449 private:
 450   nsString& mValue;
 451   GetterType mType;
 452   nsRefPtr<URLProxy> mURLProxy;
 453 };
 454
 455 // This class is the generic setter for any URL property.
 456 class SetterRunnable : public URLRunnable
 457 {
 458 public:
 459   enum SetterType {
 460     SetterHref,
 461     SetterProtocol,
 462     SetterUsername,
 463     SetterPassword,
 464     SetterHost,
 465     SetterHostname,
 466     SetterPort,
 467     SetterPathname,
 468     SetterSearch,
 469     SetterHash,
 470   };
 471
 472   SetterRunnable(WorkerPrivate* aWorkerPrivate,
 473                  SetterType aType, const nsAString& aValue,
 474                  URLProxy* aURLProxy, mozilla::ErrorResult& aRv)
 475   : URLRunnable(aWorkerPrivate)
 476   , mValue(aValue)
 477   , mType(aType)
 478   , mURLProxy(aURLProxy)
 479   , mRv(aRv)
 480   {
 481     mWorkerPrivate->AssertIsOnWorkerThread();
 482   }
 483
 484   void
 485   MainThreadRun()
 486   {
 487     AssertIsOnMainThread();
 488
 489     switch (mType) {
 490       case SetterHref:
 491         mURLProxy->URL()->SetHref(mValue, mRv);
 492         break;
 493
 494       case SetterProtocol:
 495         mURLProxy->URL()->SetProtocol(mValue);
 496         break;
 497
 498       case SetterUsername:
 499         mURLProxy->URL()->SetUsername(mValue);
 500         break;
 501
 502       case SetterPassword:
 503         mURLProxy->URL()->SetPassword(mValue);
 504         break;
 505
 506       case SetterHost:
 507         mURLProxy->URL()->SetHost(mValue);
 508         break;
 509
 510       case SetterHostname:
 511         mURLProxy->URL()->SetHostname(mValue);
 512         break;
 513
 514       case SetterPort:
 515         mURLProxy->URL()->SetPort(mValue);
 516         break;
 517
 518       case SetterPathname:
 519         mURLProxy->URL()->SetPathname(mValue);
 520         break;
 521
 522       case SetterSearch:
 523         mURLProxy->URL()->SetSearch(mValue);
 524         break;
 525
 526       case SetterHash:
 527         mURLProxy->URL()->SetHash(mValue);
 528         break;
 529     }
 530   }
 531
 532 private:
 533   const nsString mValue;
 534   SetterType mType;
 535   nsRefPtr<URLProxy> mURLProxy;
 536   mozilla::ErrorResult& mRv;
 537 };
 538
 539 // static
 540 URL*
 541 URL::Constructor(const GlobalObject& aGlobal, const nsAString& aUrl,
 542                  URL& aBase, ErrorResult& aRv)
 543 {
 544   JSContext* cx = aGlobal.GetContext();
 545   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 546
 547   nsRefPtr<ConstructorRunnable> runnable =
 548     new ConstructorRunnable(workerPrivate, aUrl, aBase.GetURLProxy(), aRv);
 549
 550   if (!runnable->Dispatch(cx)) {
 551     JS_ReportPendingException(cx);
 552   }
 553
 554   nsRefPtr<URLProxy> proxy = runnable->GetURLProxy();
 555   if (!proxy) {
 556     aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
 557     return nullptr;
 558   }
 559
 560   return new URL(workerPrivate, proxy);
 561 }
 562
 563 // static
 564 URL*
 565 URL::Constructor(const GlobalObject& aGlobal, const nsAString& aUrl,
 566                  const nsAString& aBase, ErrorResult& aRv)
 567 {
 568   JSContext* cx = aGlobal.GetContext();
 569   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 570
 571   nsRefPtr<ConstructorRunnable> runnable =
 572     new ConstructorRunnable(workerPrivate, aUrl, aBase, aRv);
 573
 574   if (!runnable->Dispatch(cx)) {
 575     JS_ReportPendingException(cx);
 576   }
 577
 578   nsRefPtr<URLProxy> proxy = runnable->GetURLProxy();
 579   if (!proxy) {
 580     aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
 581     return nullptr;
 582   }
 583
 584   return new URL(workerPrivate, proxy);
 585 }
 586
 587 URL::URL(WorkerPrivate* aWorkerPrivate, URLProxy* aURLProxy)
 588   : mWorkerPrivate(aWorkerPrivate)
 589   , mURLProxy(aURLProxy)
 590 {
 591   MOZ_COUNT_CTOR(workers::URL);
 592 }
 593
 594 URL::~URL()
 595 {
 596   MOZ_COUNT_DTOR(workers::URL);
 597
 598   if (mURLProxy) {
 599     nsRefPtr<TeardownRunnable> runnable = new TeardownRunnable(mURLProxy);
 600     mURLProxy = nullptr;
 601
 602     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
 603       NS_ERROR("Failed to dispatch teardown runnable!");
 604     }
 605   }
 606 }
 607
 608 JSObject*
 609 URL::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aScope,
 610                 bool* aTookOwnership)
 611 {
 612   return URLBinding_workers::Wrap(aCx, aScope, this, aTookOwnership);
 613 }
 614
 615 void
 616 URL::GetHref(nsString& aHref) const
 617 {
 618   nsRefPtr<GetterRunnable> runnable =
 619     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHref, aHref,
 620                        mURLProxy);
 621
 622   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 623     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 624   }
 625 }
 626
 627 void
 628 URL::SetHref(const nsAString& aHref, ErrorResult& aRv)
 629 {
 630   nsRefPtr<SetterRunnable> runnable =
 631     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHref, aHref,
 632                        mURLProxy, aRv);
 633
 634   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 635     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 636   }
 637 }
 638
 639 void
 640 URL::GetOrigin(nsString& aOrigin) const
 641 {
 642   nsRefPtr<GetterRunnable> runnable =
 643     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterOrigin, aOrigin,
 644                        mURLProxy);
 645
 646   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 647     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 648   }
 649 }
 650
 651 void
 652 URL::GetProtocol(nsString& aProtocol) const
 653 {
 654   nsRefPtr<GetterRunnable> runnable =
 655     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterProtocol, aProtocol,
 656                        mURLProxy);
 657
 658   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 659     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 660   }
 661 }
 662
 663 void
 664 URL::SetProtocol(const nsAString& aProtocol)
 665 {
 666   ErrorResult rv;
 667   nsRefPtr<SetterRunnable> runnable =
 668     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterProtocol,
 669                        aProtocol, mURLProxy, rv);
 670
 671   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 672     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 673   }
 674 }
 675
 676 void
 677 URL::GetUsername(nsString& aUsername) const
 678 {
 679   nsRefPtr<GetterRunnable> runnable =
 680     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterUsername, aUsername,
 681                        mURLProxy);
 682
 683   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 684     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 685   }
 686 }
 687
 688 void
 689 URL::SetUsername(const nsAString& aUsername)
 690 {
 691   ErrorResult rv;
 692   nsRefPtr<SetterRunnable> runnable =
 693     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterUsername,
 694                        aUsername, mURLProxy, rv);
 695
 696   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 697     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 698   }
 699 }
 700
 701 void
 702 URL::GetPassword(nsString& aPassword) const
 703 {
 704   nsRefPtr<GetterRunnable> runnable =
 705     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPassword, aPassword,
 706                        mURLProxy);
 707
 708   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 709     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 710   }
 711 }
 712
 713 void
 714 URL::SetPassword(const nsAString& aPassword)
 715 {
 716   ErrorResult rv;
 717   nsRefPtr<SetterRunnable> runnable =
 718     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPassword,
 719                        aPassword, mURLProxy, rv);
 720
 721   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 722     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 723   }
 724 }
 725
 726 void
 727 URL::GetHost(nsString& aHost) const
 728 {
 729   nsRefPtr<GetterRunnable> runnable =
 730     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHost, aHost,
 731                        mURLProxy);
 732
 733   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 734     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 735   }
 736 }
 737
 738 void
 739 URL::SetHost(const nsAString& aHost)
 740 {
 741   ErrorResult rv;
 742   nsRefPtr<SetterRunnable> runnable =
 743     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHost,
 744                        aHost, mURLProxy, rv);
 745
 746   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 747     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 748   }
 749 }
 750
 751 void
 752 URL::GetHostname(nsString& aHostname) const
 753 {
 754   nsRefPtr<GetterRunnable> runnable =
 755     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHostname, aHostname,
 756                        mURLProxy);
 757
 758   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 759     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 760   }
 761 }
 762
 763 void
 764 URL::SetHostname(const nsAString& aHostname)
 765 {
 766   ErrorResult rv;
 767   nsRefPtr<SetterRunnable> runnable =
 768     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHostname,
 769                        aHostname, mURLProxy, rv);
 770
 771   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 772     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 773   }
 774 }
 775
 776 void
 777 URL::GetPort(nsString& aPort) const
 778 {
 779   nsRefPtr<GetterRunnable> runnable =
 780     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPort, aPort,
 781                        mURLProxy);
 782
 783   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 784     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 785   }
 786 }
 787
 788 void
 789 URL::SetPort(const nsAString& aPort)
 790 {
 791   ErrorResult rv;
 792   nsRefPtr<SetterRunnable> runnable =
 793     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPort,
 794                        aPort, mURLProxy, rv);
 795
 796   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 797     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 798   }
 799 }
 800
 801 void
 802 URL::GetPathname(nsString& aPathname) const
 803 {
 804   nsRefPtr<GetterRunnable> runnable =
 805     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPathname, aPathname,
 806                        mURLProxy);
 807
 808   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 809     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 810   }
 811 }
 812
 813 void
 814 URL::SetPathname(const nsAString& aPathname)
 815 {
 816   ErrorResult rv;
 817   nsRefPtr<SetterRunnable> runnable =
 818     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPathname,
 819                        aPathname, mURLProxy, rv);
 820
 821   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 822     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 823   }
 824 }
 825
 826 void
 827 URL::GetSearch(nsString& aSearch) const
 828 {
 829   nsRefPtr<GetterRunnable> runnable =
 830     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterSearch, aSearch,
 831                        mURLProxy);
 832
 833   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 834     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 835   }
 836 }
 837
 838 void
 839 URL::SetSearch(const nsAString& aSearch)
 840 {
 841   ErrorResult rv;
 842   nsRefPtr<SetterRunnable> runnable =
 843     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterSearch,
 844                        aSearch, mURLProxy, rv);
 845
 846   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 847     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 848   }
 849 }
 850
 851 void
 852 URL::GetHash(nsString& aHash) const
 853 {
 854   nsRefPtr<GetterRunnable> runnable =
 855     new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHash, aHash,
 856                        mURLProxy);
 857
 858   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 859     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 860   }
 861 }
 862
 863 void
 864 URL::SetHash(const nsAString& aHash)
 865 {
 866   ErrorResult rv;
 867   nsRefPtr<SetterRunnable> runnable =
 868     new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHash,
 869                        aHash, mURLProxy, rv);
 870
 871   if (!runnable->Dispatch(mWorkerPrivate->GetJSContext())) {
 872     JS_ReportPendingException(mWorkerPrivate->GetJSContext());
 873   }
 874 }
 875
 876 // static
 877 void
 878 URL::CreateObjectURL(const GlobalObject& aGlobal, JSObject* aBlob,
 879                      const mozilla::dom::objectURLOptions& aOptions,
 880                      nsString& aResult, mozilla::ErrorResult& aRv)
 881 {
 882   JSContext* cx = aGlobal.GetContext();
 883   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 884
 885   nsCOMPtr<nsIDOMBlob> blob = file::GetDOMBlobFromJSObject(aBlob);
 886   if (!blob) {
 887     SetDOMStringToNull(aResult);
 888
 889     NS_NAMED_LITERAL_STRING(argStr, "Argument 1 of URL.createObjectURL");
 890     NS_NAMED_LITERAL_STRING(blobStr, "Blob");
 891     aRv.ThrowTypeError(MSG_DOES_NOT_IMPLEMENT_INTERFACE, &argStr, &blobStr);
 892     return;
 893   }
 894
 895   nsRefPtr<CreateURLRunnable> runnable =
 896     new CreateURLRunnable(workerPrivate, blob, aOptions, aResult);
 897
 898   if (!runnable->Dispatch(cx)) {
 899     JS_ReportPendingException(cx);
 900   }
 901 }
 902
 903 // static
 904 void
 905 URL::CreateObjectURL(const GlobalObject& aGlobal, JSObject& aBlob,
 906                      const mozilla::dom::objectURLOptions& aOptions,
 907                      nsString& aResult, mozilla::ErrorResult& aRv)
 908 {
 909   return CreateObjectURL(aGlobal, &aBlob, aOptions, aResult, aRv);
 910 }
 911
 912 // static
 913 void
 914 URL::RevokeObjectURL(const GlobalObject& aGlobal, const nsAString& aUrl)
 915 {
 916   JSContext* cx = aGlobal.GetContext();
 917   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 918
 919   nsRefPtr<RevokeURLRunnable> runnable =
 920     new RevokeURLRunnable(workerPrivate, aUrl);
 921
 922   if (!runnable->Dispatch(cx)) {
 923     JS_ReportPendingException(cx);
 924   }
 925 }
 926
 927 END_WORKERS_NAMESPACE