netwerk/protocol/http/NullHttpChannel.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "NullHttpChannel.h"
   6 #include "nsContentUtils.h"
   7 #include "nsContentSecurityManager.h"
   8 #include "nsIScriptSecurityManager.h"
   9 #include "nsIStreamListener.h"
  10
  11 namespace mozilla {
  12 namespace net {
  13
  14 NS_IMPL_ISUPPORTS(NullHttpChannel, nsINullChannel, nsIHttpChannel,
  15                   nsIIdentChannel, nsITimedChannel)
  16
  17 NullHttpChannel::NullHttpChannel() {
  18   mChannelCreationTime = PR_Now();
  19   mChannelCreationTimestamp = TimeStamp::Now();
  20   mAsyncOpenTime = TimeStamp::Now();
  21 }
  22
  23 NullHttpChannel::NullHttpChannel(nsIHttpChannel* chan)
  24     : mAllRedirectsSameOrigin(false), mAllRedirectsPassTimingAllowCheck(false) {
  25   nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
  26   ssm->GetChannelURIPrincipal(chan, getter_AddRefs(mResourcePrincipal));
  27
  28   Unused << chan->GetResponseHeader("Timing-Allow-Origin"_ns,
  29                                     mTimingAllowOriginHeader);
  30   chan->GetURI(getter_AddRefs(mURI));
  31   chan->GetOriginalURI(getter_AddRefs(mOriginalURI));
  32
  33   mChannelCreationTime = PR_Now();
  34   mChannelCreationTimestamp = TimeStamp::Now();
  35   mAsyncOpenTime = TimeStamp::Now();
  36
  37   nsCOMPtr<nsITimedChannel> timedChanel(do_QueryInterface(chan));
  38   if (timedChanel) {
  39     timedChanel->GetInitiatorType(mInitiatorType);
  40   }
  41 }
  42
  43 nsresult NullHttpChannel::Init(nsIURI* aURI, uint32_t aCaps,
  44                                nsProxyInfo* aProxyInfo,
  45                                uint32_t aProxyResolveFlags, nsIURI* aProxyURI) {
  46   mURI = aURI;
  47   mOriginalURI = aURI;
  48   return NS_OK;
  49 }
  50
  51 //-----------------------------------------------------------------------------
  52 // NullHttpChannel::nsIHttpChannel
  53 //-----------------------------------------------------------------------------
  54
  55 NS_IMETHODIMP
  56 NullHttpChannel::GetChannelId(uint64_t* aChannelId) {
  57   return NS_ERROR_NOT_IMPLEMENTED;
  58 }
  59
  60 NS_IMETHODIMP
  61 NullHttpChannel::SetChannelId(uint64_t aChannelId) {
  62   return NS_ERROR_NOT_IMPLEMENTED;
  63 }
  64
  65 NS_IMETHODIMP
  66 NullHttpChannel::GetTopLevelContentWindowId(uint64_t* aWindowId) {
  67   return NS_ERROR_NOT_IMPLEMENTED;
  68 }
  69
  70 NS_IMETHODIMP
  71 NullHttpChannel::SetTopLevelContentWindowId(uint64_t aWindowId) {
  72   return NS_ERROR_NOT_IMPLEMENTED;
  73 }
  74
  75 NS_IMETHODIMP
  76 NullHttpChannel::GetBrowserId(uint64_t*) { return NS_ERROR_NOT_IMPLEMENTED; }
  77
  78 NS_IMETHODIMP
  79 NullHttpChannel::SetBrowserId(uint64_t) { return NS_ERROR_NOT_IMPLEMENTED; }
  80
  81 NS_IMETHODIMP
  82 NullHttpChannel::GetTransferSize(uint64_t* aTransferSize) {
  83   return NS_ERROR_NOT_IMPLEMENTED;
  84 }
  85
  86 NS_IMETHODIMP
  87 NullHttpChannel::GetRequestSize(uint64_t* aRequestSize) {
  88   return NS_ERROR_NOT_IMPLEMENTED;
  89 }
  90
  91 NS_IMETHODIMP
  92 NullHttpChannel::GetDecodedBodySize(uint64_t* aDecodedBodySize) {
  93   return NS_ERROR_NOT_IMPLEMENTED;
  94 }
  95
  96 NS_IMETHODIMP
  97 NullHttpChannel::GetRequestMethod(nsACString& aRequestMethod) {
  98   return NS_ERROR_NOT_IMPLEMENTED;
  99 }
 100
 101 NS_IMETHODIMP
 102 NullHttpChannel::SetRequestMethod(const nsACString& aRequestMethod) {
 103   return NS_ERROR_NOT_IMPLEMENTED;
 104 }
 105
 106 NS_IMETHODIMP
 107 NullHttpChannel::GetReferrerInfo(nsIReferrerInfo** aReferrerInfo) {
 108   return NS_ERROR_NOT_IMPLEMENTED;
 109 }
 110
 111 NS_IMETHODIMP
 112 NullHttpChannel::SetReferrerInfo(nsIReferrerInfo* aReferrerInfo) {
 113   return NS_ERROR_NOT_IMPLEMENTED;
 114 }
 115
 116 NS_IMETHODIMP
 117 NullHttpChannel::SetReferrerInfoWithoutClone(nsIReferrerInfo* aReferrerInfo) {
 118   return NS_ERROR_NOT_IMPLEMENTED;
 119 }
 120
 121 NS_IMETHODIMP
 122 NullHttpChannel::GetRequestHeader(const nsACString& aHeader,
 123                                   nsACString& _retval) {
 124   _retval.Truncate();
 125   return NS_ERROR_NOT_IMPLEMENTED;
 126 }
 127
 128 NS_IMETHODIMP
 129 NullHttpChannel::SetRequestHeader(const nsACString& aHeader,
 130                                   const nsACString& aValue, bool aMerge) {
 131   return NS_ERROR_NOT_IMPLEMENTED;
 132 }
 133
 134 NS_IMETHODIMP
 135 NullHttpChannel::SetNewReferrerInfo(const nsACString& aUrl,
 136                                     nsIReferrerInfo::ReferrerPolicyIDL aPolicy,
 137                                     bool aSendReferrer) {
 138   return NS_ERROR_NOT_IMPLEMENTED;
 139 }
 140
 141 NS_IMETHODIMP
 142 NullHttpChannel::SetEmptyRequestHeader(const nsACString& aHeader) {
 143   return NS_ERROR_NOT_IMPLEMENTED;
 144 }
 145
 146 NS_IMETHODIMP
 147 NullHttpChannel::VisitRequestHeaders(nsIHttpHeaderVisitor* aVisitor) {
 148   return NS_ERROR_NOT_IMPLEMENTED;
 149 }
 150
 151 NS_IMETHODIMP
 152 NullHttpChannel::VisitNonDefaultRequestHeaders(nsIHttpHeaderVisitor* aVisitor) {
 153   return NS_ERROR_NOT_IMPLEMENTED;
 154 }
 155
 156 NS_IMETHODIMP
 157 NullHttpChannel::GetAllowSTS(bool* aAllowSTS) {
 158   return NS_ERROR_NOT_IMPLEMENTED;
 159 }
 160
 161 NS_IMETHODIMP
 162 NullHttpChannel::SetAllowSTS(bool aAllowSTS) {
 163   return NS_ERROR_NOT_IMPLEMENTED;
 164 }
 165
 166 NS_IMETHODIMP
 167 NullHttpChannel::GetRedirectionLimit(uint32_t* aRedirectionLimit) {
 168   return NS_ERROR_NOT_IMPLEMENTED;
 169 }
 170
 171 NS_IMETHODIMP
 172 NullHttpChannel::SetRedirectionLimit(uint32_t aRedirectionLimit) {
 173   return NS_ERROR_NOT_IMPLEMENTED;
 174 }
 175
 176 NS_IMETHODIMP
 177 NullHttpChannel::GetResponseStatus(uint32_t* aResponseStatus) {
 178   return NS_ERROR_NOT_IMPLEMENTED;
 179 }
 180
 181 NS_IMETHODIMP
 182 NullHttpChannel::GetResponseStatusText(nsACString& aResponseStatusText) {
 183   return NS_ERROR_NOT_IMPLEMENTED;
 184 }
 185
 186 NS_IMETHODIMP
 187 NullHttpChannel::GetRequestSucceeded(bool* aRequestSucceeded) {
 188   return NS_ERROR_NOT_IMPLEMENTED;
 189 }
 190
 191 NS_IMETHODIMP
 192 NullHttpChannel::GetResponseHeader(const nsACString& header,
 193                                    nsACString& _retval) {
 194   _retval.Truncate();
 195   return NS_ERROR_NOT_IMPLEMENTED;
 196 }
 197
 198 NS_IMETHODIMP
 199 NullHttpChannel::SetResponseHeader(const nsACString& header,
 200                                    const nsACString& value, bool merge) {
 201   return NS_ERROR_NOT_IMPLEMENTED;
 202 }
 203
 204 NS_IMETHODIMP
 205 NullHttpChannel::VisitResponseHeaders(nsIHttpHeaderVisitor* aVisitor) {
 206   return NS_ERROR_NOT_IMPLEMENTED;
 207 }
 208
 209 NS_IMETHODIMP
 210 NullHttpChannel::GetOriginalResponseHeader(const nsACString& header,
 211                                            nsIHttpHeaderVisitor* aVisitor) {
 212   return NS_ERROR_NOT_IMPLEMENTED;
 213 }
 214
 215 NS_IMETHODIMP
 216 NullHttpChannel::VisitOriginalResponseHeaders(nsIHttpHeaderVisitor* aVisitor) {
 217   return NS_ERROR_NOT_IMPLEMENTED;
 218 }
 219
 220 NS_IMETHODIMP
 221 NullHttpChannel::ShouldStripRequestBodyHeader(const nsACString& aMethod,
 222                                               bool* aResult) {
 223   return NS_ERROR_NOT_IMPLEMENTED;
 224 }
 225
 226 NS_IMETHODIMP
 227 NullHttpChannel::IsNoStoreResponse(bool* _retval) {
 228   return NS_ERROR_NOT_IMPLEMENTED;
 229 }
 230
 231 NS_IMETHODIMP
 232 NullHttpChannel::IsNoCacheResponse(bool* _retval) {
 233   return NS_ERROR_NOT_IMPLEMENTED;
 234 }
 235
 236 NS_IMETHODIMP
 237 NullHttpChannel::IsPrivateResponse(bool* _retval) {
 238   return NS_ERROR_NOT_IMPLEMENTED;
 239 }
 240
 241 NS_IMETHODIMP
 242 NullHttpChannel::RedirectTo(nsIURI* aNewURI) {
 243   return NS_ERROR_NOT_IMPLEMENTED;
 244 }
 245
 246 NS_IMETHODIMP
 247 NullHttpChannel::UpgradeToSecure() { return NS_ERROR_NOT_IMPLEMENTED; }
 248
 249 NS_IMETHODIMP
 250 NullHttpChannel::GetRequestContextID(uint64_t* _retval) {
 251   return NS_ERROR_NOT_IMPLEMENTED;
 252 }
 253
 254 NS_IMETHODIMP
 255 NullHttpChannel::SetRequestContextID(uint64_t rcID) {
 256   return NS_ERROR_NOT_IMPLEMENTED;
 257 }
 258
 259 NS_IMETHODIMP
 260 NullHttpChannel::GetProtocolVersion(nsACString& aProtocolVersion) {
 261   return NS_ERROR_NOT_IMPLEMENTED;
 262 }
 263
 264 NS_IMETHODIMP
 265 NullHttpChannel::GetEncodedBodySize(uint64_t* aEncodedBodySize) {
 266   return NS_ERROR_NOT_IMPLEMENTED;
 267 }
 268
 269 void NullHttpChannel::SetSource(
 270     mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource) {}
 271
 272 //-----------------------------------------------------------------------------
 273 // NullHttpChannel::nsIChannel
 274 //-----------------------------------------------------------------------------
 275
 276 NS_IMETHODIMP
 277 NullHttpChannel::GetOriginalURI(nsIURI** aOriginalURI) {
 278   *aOriginalURI = do_AddRef(mOriginalURI).take();
 279   return NS_OK;
 280 }
 281
 282 NS_IMETHODIMP
 283 NullHttpChannel::SetOriginalURI(nsIURI* aOriginalURI) {
 284   mOriginalURI = aOriginalURI;
 285   return NS_OK;
 286 }
 287
 288 NS_IMETHODIMP
 289 NullHttpChannel::GetURI(nsIURI** aURI) {
 290   *aURI = do_AddRef(mURI).take();
 291   return NS_OK;
 292 }
 293
 294 NS_IMETHODIMP
 295 NullHttpChannel::GetOwner(nsISupports** aOwner) {
 296   return NS_ERROR_NOT_IMPLEMENTED;
 297 }
 298
 299 NS_IMETHODIMP
 300 NullHttpChannel::SetOwner(nsISupports* aOwner) {
 301   return NS_ERROR_NOT_IMPLEMENTED;
 302 }
 303
 304 NS_IMETHODIMP
 305 NullHttpChannel::GetNotificationCallbacks(
 306     nsIInterfaceRequestor** aNotificationCallbacks) {
 307   return NS_ERROR_NOT_IMPLEMENTED;
 308 }
 309
 310 NS_IMETHODIMP
 311 NullHttpChannel::SetNotificationCallbacks(
 312     nsIInterfaceRequestor* aNotificationCallbacks) {
 313   return NS_ERROR_NOT_IMPLEMENTED;
 314 }
 315
 316 NS_IMETHODIMP
 317 NullHttpChannel::GetSecurityInfo(nsITransportSecurityInfo** aSecurityInfo) {
 318   return NS_ERROR_NOT_IMPLEMENTED;
 319 }
 320
 321 NS_IMETHODIMP
 322 NullHttpChannel::GetContentType(nsACString& aContentType) {
 323   return NS_ERROR_NOT_IMPLEMENTED;
 324 }
 325
 326 NS_IMETHODIMP
 327 NullHttpChannel::SetContentType(const nsACString& aContentType) {
 328   return NS_ERROR_NOT_IMPLEMENTED;
 329 }
 330
 331 NS_IMETHODIMP
 332 NullHttpChannel::GetContentCharset(nsACString& aContentCharset) {
 333   return NS_ERROR_NOT_IMPLEMENTED;
 334 }
 335
 336 NS_IMETHODIMP
 337 NullHttpChannel::SetContentCharset(const nsACString& aContentCharset) {
 338   return NS_ERROR_NOT_IMPLEMENTED;
 339 }
 340
 341 NS_IMETHODIMP
 342 NullHttpChannel::GetContentLength(int64_t* aContentLength) {
 343   return NS_ERROR_NOT_IMPLEMENTED;
 344 }
 345
 346 NS_IMETHODIMP
 347 NullHttpChannel::SetContentLength(int64_t aContentLength) {
 348   return NS_ERROR_NOT_IMPLEMENTED;
 349 }
 350
 351 NS_IMETHODIMP
 352 NullHttpChannel::Open(nsIInputStream** aStream) {
 353   nsCOMPtr<nsIStreamListener> listener;
 354   nsresult rv =
 355       nsContentSecurityManager::doContentSecurityCheck(this, listener);
 356   NS_ENSURE_SUCCESS(rv, rv);
 357
 358   return NS_ERROR_NOT_IMPLEMENTED;
 359 }
 360
 361 NS_IMETHODIMP
 362 NullHttpChannel::AsyncOpen(nsIStreamListener* aListener) {
 363   nsCOMPtr<nsIStreamListener> listener = aListener;
 364   nsresult rv =
 365       nsContentSecurityManager::doContentSecurityCheck(this, listener);
 366   NS_ENSURE_SUCCESS(rv, rv);
 367   return NS_ERROR_NOT_IMPLEMENTED;
 368 }
 369
 370 NS_IMETHODIMP
 371 NullHttpChannel::GetContentDisposition(uint32_t* aContentDisposition) {
 372   return NS_ERROR_NOT_IMPLEMENTED;
 373 }
 374
 375 NS_IMETHODIMP
 376 NullHttpChannel::SetContentDisposition(uint32_t aContentDisposition) {
 377   return NS_ERROR_NOT_IMPLEMENTED;
 378 }
 379
 380 NS_IMETHODIMP
 381 NullHttpChannel::GetContentDispositionFilename(
 382     nsAString& aContentDispositionFilename) {
 383   return NS_ERROR_NOT_IMPLEMENTED;
 384 }
 385
 386 NS_IMETHODIMP
 387 NullHttpChannel::SetContentDispositionFilename(
 388     const nsAString& aContentDispositionFilename) {
 389   return NS_ERROR_NOT_IMPLEMENTED;
 390 }
 391
 392 NS_IMETHODIMP
 393 NullHttpChannel::GetContentDispositionHeader(
 394     nsACString& aContentDispositionHeader) {
 395   return NS_ERROR_NOT_IMPLEMENTED;
 396 }
 397
 398 NS_IMETHODIMP
 399 NullHttpChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) {
 400   return NS_ERROR_NOT_IMPLEMENTED;
 401 }
 402
 403 NS_IMETHODIMP
 404 NullHttpChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) {
 405   return NS_ERROR_NOT_IMPLEMENTED;
 406 }
 407
 408 //-----------------------------------------------------------------------------
 409 // NullHttpChannel::nsIRequest
 410 //-----------------------------------------------------------------------------
 411
 412 NS_IMETHODIMP
 413 NullHttpChannel::GetName(nsACString& aName) { return NS_ERROR_NOT_IMPLEMENTED; }
 414
 415 NS_IMETHODIMP
 416 NullHttpChannel::IsPending(bool* _retval) { return NS_ERROR_NOT_IMPLEMENTED; }
 417
 418 NS_IMETHODIMP
 419 NullHttpChannel::GetStatus(nsresult* aStatus) {
 420   return NS_ERROR_NOT_IMPLEMENTED;
 421 }
 422
 423 NS_IMETHODIMP NullHttpChannel::SetCanceledReason(const nsACString& aReason) {
 424   return NS_ERROR_NOT_IMPLEMENTED;
 425 }
 426
 427 NS_IMETHODIMP NullHttpChannel::GetCanceledReason(nsACString& aReason) {
 428   return NS_ERROR_NOT_IMPLEMENTED;
 429 }
 430
 431 NS_IMETHODIMP NullHttpChannel::CancelWithReason(nsresult aStatus,
 432                                                 const nsACString& aReason) {
 433   return NS_ERROR_NOT_IMPLEMENTED;
 434 }
 435
 436 NS_IMETHODIMP
 437 NullHttpChannel::Cancel(nsresult aStatus) { return NS_ERROR_NOT_IMPLEMENTED; }
 438
 439 NS_IMETHODIMP
 440 NullHttpChannel::GetCanceled(bool* aCanceled) {
 441   return NS_ERROR_NOT_IMPLEMENTED;
 442 }
 443
 444 NS_IMETHODIMP
 445 NullHttpChannel::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; }
 446
 447 NS_IMETHODIMP
 448 NullHttpChannel::Resume() { return NS_ERROR_NOT_IMPLEMENTED; }
 449
 450 NS_IMETHODIMP
 451 NullHttpChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
 452   return NS_ERROR_NOT_IMPLEMENTED;
 453 }
 454
 455 NS_IMETHODIMP
 456 NullHttpChannel::SetLoadGroup(nsILoadGroup* aLoadGroup) {
 457   return NS_ERROR_NOT_IMPLEMENTED;
 458 }
 459
 460 NS_IMETHODIMP
 461 NullHttpChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
 462   return NS_ERROR_NOT_IMPLEMENTED;
 463 }
 464
 465 NS_IMETHODIMP
 466 NullHttpChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
 467   return NS_ERROR_NOT_IMPLEMENTED;
 468 }
 469
 470 NS_IMETHODIMP
 471 NullHttpChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
 472   return NS_ERROR_NOT_IMPLEMENTED;
 473 }
 474
 475 NS_IMETHODIMP
 476 NullHttpChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
 477   return NS_ERROR_NOT_IMPLEMENTED;
 478 }
 479
 480 NS_IMETHODIMP
 481 NullHttpChannel::GetIsDocument(bool* aIsDocument) {
 482   return NS_ERROR_NOT_IMPLEMENTED;
 483 }
 484
 485 //-----------------------------------------------------------------------------
 486 // NullHttpChannel::nsITimedChannel
 487 //-----------------------------------------------------------------------------
 488
 489 NS_IMETHODIMP
 490 NullHttpChannel::GetTimingEnabled(bool* aTimingEnabled) {
 491   // We don't want to report timing for null channels.
 492   *aTimingEnabled = false;
 493   return NS_OK;
 494 }
 495
 496 NS_IMETHODIMP
 497 NullHttpChannel::SetTimingEnabled(bool aTimingEnabled) {
 498   return NS_ERROR_NOT_IMPLEMENTED;
 499 }
 500
 501 NS_IMETHODIMP
 502 NullHttpChannel::GetRedirectCount(uint8_t* aRedirectCount) {
 503   return NS_ERROR_NOT_IMPLEMENTED;
 504 }
 505
 506 NS_IMETHODIMP
 507 NullHttpChannel::SetRedirectCount(uint8_t aRedirectCount) {
 508   return NS_ERROR_NOT_IMPLEMENTED;
 509 }
 510
 511 NS_IMETHODIMP
 512 NullHttpChannel::GetInternalRedirectCount(uint8_t* aRedirectCount) {
 513   return NS_ERROR_NOT_IMPLEMENTED;
 514 }
 515
 516 NS_IMETHODIMP
 517 NullHttpChannel::SetInternalRedirectCount(uint8_t aRedirectCount) {
 518   return NS_ERROR_NOT_IMPLEMENTED;
 519 }
 520
 521 NS_IMETHODIMP
 522 NullHttpChannel::GetChannelCreation(mozilla::TimeStamp* aChannelCreation) {
 523   *aChannelCreation = mChannelCreationTimestamp;
 524   return NS_OK;
 525 }
 526
 527 NS_IMETHODIMP
 528 NullHttpChannel::SetChannelCreation(TimeStamp aValue) {
 529   MOZ_DIAGNOSTIC_ASSERT(!aValue.IsNull());
 530   TimeDuration adjust = aValue - mChannelCreationTimestamp;
 531   mChannelCreationTimestamp = aValue;
 532   mChannelCreationTime += (PRTime)adjust.ToMicroseconds();
 533   return NS_OK;
 534 }
 535
 536 NS_IMETHODIMP
 537 NullHttpChannel::GetAsyncOpen(mozilla::TimeStamp* aAsyncOpen) {
 538   *aAsyncOpen = mAsyncOpenTime;
 539   return NS_OK;
 540 }
 541
 542 NS_IMETHODIMP
 543 NullHttpChannel::SetAsyncOpen(TimeStamp aValue) {
 544   MOZ_DIAGNOSTIC_ASSERT(!aValue.IsNull());
 545   mAsyncOpenTime = aValue;
 546   return NS_OK;
 547 }
 548
 549 NS_IMETHODIMP
 550 NullHttpChannel::GetLaunchServiceWorkerStart(mozilla::TimeStamp* _retval) {
 551   MOZ_ASSERT(_retval);
 552   *_retval = mAsyncOpenTime;
 553   return NS_OK;
 554 }
 555
 556 NS_IMETHODIMP
 557 NullHttpChannel::SetLaunchServiceWorkerStart(mozilla::TimeStamp aTimeStamp) {
 558   return NS_OK;
 559 }
 560
 561 NS_IMETHODIMP
 562 NullHttpChannel::GetLaunchServiceWorkerEnd(mozilla::TimeStamp* _retval) {
 563   MOZ_ASSERT(_retval);
 564   *_retval = mAsyncOpenTime;
 565   return NS_OK;
 566 }
 567
 568 NS_IMETHODIMP
 569 NullHttpChannel::SetLaunchServiceWorkerEnd(mozilla::TimeStamp aTimeStamp) {
 570   return NS_OK;
 571 }
 572
 573 NS_IMETHODIMP
 574 NullHttpChannel::GetDispatchFetchEventStart(mozilla::TimeStamp* _retval) {
 575   MOZ_ASSERT(_retval);
 576   *_retval = mAsyncOpenTime;
 577   return NS_OK;
 578 }
 579
 580 NS_IMETHODIMP
 581 NullHttpChannel::SetDispatchFetchEventStart(mozilla::TimeStamp aTimeStamp) {
 582   return NS_OK;
 583 }
 584
 585 NS_IMETHODIMP
 586 NullHttpChannel::GetDispatchFetchEventEnd(mozilla::TimeStamp* _retval) {
 587   MOZ_ASSERT(_retval);
 588   *_retval = mAsyncOpenTime;
 589   return NS_OK;
 590 }
 591
 592 NS_IMETHODIMP
 593 NullHttpChannel::SetDispatchFetchEventEnd(mozilla::TimeStamp aTimeStamp) {
 594   return NS_OK;
 595 }
 596
 597 NS_IMETHODIMP
 598 NullHttpChannel::GetHandleFetchEventStart(mozilla::TimeStamp* _retval) {
 599   MOZ_ASSERT(_retval);
 600   *_retval = mAsyncOpenTime;
 601   return NS_OK;
 602 }
 603
 604 NS_IMETHODIMP
 605 NullHttpChannel::SetHandleFetchEventStart(mozilla::TimeStamp aTimeStamp) {
 606   return NS_OK;
 607 }
 608
 609 NS_IMETHODIMP
 610 NullHttpChannel::GetHandleFetchEventEnd(mozilla::TimeStamp* _retval) {
 611   MOZ_ASSERT(_retval);
 612   *_retval = mAsyncOpenTime;
 613   return NS_OK;
 614 }
 615
 616 NS_IMETHODIMP
 617 NullHttpChannel::SetHandleFetchEventEnd(mozilla::TimeStamp aTimeStamp) {
 618   return NS_OK;
 619 }
 620
 621 NS_IMETHODIMP
 622 NullHttpChannel::GetDomainLookupStart(mozilla::TimeStamp* aDomainLookupStart) {
 623   *aDomainLookupStart = mAsyncOpenTime;
 624   return NS_OK;
 625 }
 626
 627 NS_IMETHODIMP
 628 NullHttpChannel::GetDomainLookupEnd(mozilla::TimeStamp* aDomainLookupEnd) {
 629   *aDomainLookupEnd = mAsyncOpenTime;
 630   return NS_OK;
 631 }
 632
 633 NS_IMETHODIMP
 634 NullHttpChannel::GetConnectStart(mozilla::TimeStamp* aConnectStart) {
 635   *aConnectStart = mAsyncOpenTime;
 636   return NS_OK;
 637 }
 638
 639 NS_IMETHODIMP
 640 NullHttpChannel::GetTcpConnectEnd(mozilla::TimeStamp* aTcpConnectEnd) {
 641   *aTcpConnectEnd = mAsyncOpenTime;
 642   return NS_OK;
 643 }
 644
 645 NS_IMETHODIMP
 646 NullHttpChannel::GetSecureConnectionStart(
 647     mozilla::TimeStamp* aSecureConnectionStart) {
 648   *aSecureConnectionStart = mAsyncOpenTime;
 649   return NS_OK;
 650 }
 651
 652 NS_IMETHODIMP
 653 NullHttpChannel::GetConnectEnd(mozilla::TimeStamp* aConnectEnd) {
 654   *aConnectEnd = mAsyncOpenTime;
 655   return NS_OK;
 656 }
 657
 658 NS_IMETHODIMP
 659 NullHttpChannel::GetRequestStart(mozilla::TimeStamp* aRequestStart) {
 660   *aRequestStart = mAsyncOpenTime;
 661   return NS_OK;
 662 }
 663
 664 NS_IMETHODIMP
 665 NullHttpChannel::GetResponseStart(mozilla::TimeStamp* aResponseStart) {
 666   *aResponseStart = mAsyncOpenTime;
 667   return NS_OK;
 668 }
 669
 670 NS_IMETHODIMP
 671 NullHttpChannel::GetResponseEnd(mozilla::TimeStamp* aResponseEnd) {
 672   *aResponseEnd = mAsyncOpenTime;
 673   return NS_OK;
 674 }
 675
 676 NS_IMETHODIMP
 677 NullHttpChannel::GetRedirectStart(mozilla::TimeStamp* aRedirectStart) {
 678   *aRedirectStart = mAsyncOpenTime;
 679   return NS_OK;
 680 }
 681
 682 NS_IMETHODIMP
 683 NullHttpChannel::SetRedirectStart(mozilla::TimeStamp aRedirectStart) {
 684   return NS_ERROR_NOT_IMPLEMENTED;
 685 }
 686
 687 NS_IMETHODIMP
 688 NullHttpChannel::GetRedirectEnd(mozilla::TimeStamp* aRedirectEnd) {
 689   *aRedirectEnd = mAsyncOpenTime;
 690   return NS_OK;
 691 }
 692
 693 NS_IMETHODIMP
 694 NullHttpChannel::SetRedirectEnd(mozilla::TimeStamp aRedirectEnd) {
 695   return NS_ERROR_NOT_IMPLEMENTED;
 696 }
 697
 698 NS_IMETHODIMP
 699 NullHttpChannel::GetInitiatorType(nsAString& aInitiatorType) {
 700   aInitiatorType = mInitiatorType;
 701   return NS_OK;
 702 }
 703
 704 NS_IMETHODIMP
 705 NullHttpChannel::SetInitiatorType(const nsAString& aInitiatorType) {
 706   mInitiatorType = aInitiatorType;
 707   return NS_OK;
 708 }
 709
 710 NS_IMETHODIMP
 711 NullHttpChannel::GetAllRedirectsSameOrigin(bool* aAllRedirectsSameOrigin) {
 712   *aAllRedirectsSameOrigin = mAllRedirectsSameOrigin;
 713   return NS_OK;
 714 }
 715
 716 NS_IMETHODIMP
 717 NullHttpChannel::SetAllRedirectsSameOrigin(bool aAllRedirectsSameOrigin) {
 718   return NS_ERROR_NOT_IMPLEMENTED;
 719 }
 720
 721 NS_IMETHODIMP
 722 NullHttpChannel::GetAllRedirectsPassTimingAllowCheck(
 723     bool* aAllRedirectsPassTimingAllowCheck) {
 724   *aAllRedirectsPassTimingAllowCheck = mAllRedirectsPassTimingAllowCheck;
 725   return NS_OK;
 726 }
 727
 728 NS_IMETHODIMP
 729 NullHttpChannel::SetAllRedirectsPassTimingAllowCheck(
 730     bool aAllRedirectsPassTimingAllowCheck) {
 731   return NS_ERROR_NOT_IMPLEMENTED;
 732 }
 733
 734 NS_IMETHODIMP
 735 NullHttpChannel::TimingAllowCheck(nsIPrincipal* aOrigin, bool* _retval) {
 736   *_retval = false;
 737   return NS_OK;
 738 }
 739
 740 NS_IMETHODIMP
 741 NullHttpChannel::GetCacheReadStart(mozilla::TimeStamp* aCacheReadStart) {
 742   *aCacheReadStart = mAsyncOpenTime;
 743   return NS_OK;
 744 }
 745
 746 NS_IMETHODIMP
 747 NullHttpChannel::GetCacheReadEnd(mozilla::TimeStamp* aCacheReadEnd) {
 748   *aCacheReadEnd = mAsyncOpenTime;
 749   return NS_OK;
 750 }
 751
 752 NS_IMETHODIMP
 753 NullHttpChannel::GetTransactionPending(mozilla::TimeStamp* aRetVal) {
 754   *aRetVal = mAsyncOpenTime;
 755   return NS_OK;
 756 }
 757
 758 NS_IMETHODIMP
 759 NullHttpChannel::GetIsMainDocumentChannel(bool* aValue) {
 760   *aValue = false;
 761   return NS_OK;
 762 }
 763
 764 NS_IMETHODIMP
 765 NullHttpChannel::SetIsMainDocumentChannel(bool aValue) {
 766   return NS_ERROR_NOT_IMPLEMENTED;
 767 }
 768
 769 NS_IMETHODIMP
 770 NullHttpChannel::LogBlockedCORSRequest(const nsAString& aMessage,
 771                                        const nsACString& aCategor,
 772                                        bool aIsWarning) {
 773   return NS_ERROR_NOT_IMPLEMENTED;
 774 }
 775
 776 NS_IMETHODIMP
 777 NullHttpChannel::LogMimeTypeMismatch(const nsACString& aMessageName,
 778                                      bool aWarning, const nsAString& aURL,
 779                                      const nsAString& aContentType) {
 780   return NS_ERROR_NOT_IMPLEMENTED;
 781 }
 782
 783 NS_IMETHODIMP
 784 NullHttpChannel::SetReportResourceTiming(bool enabled) {
 785   return NS_ERROR_NOT_IMPLEMENTED;
 786 }
 787
 788 NS_IMETHODIMP
 789 NullHttpChannel::GetReportResourceTiming(bool* _retval) {
 790   return NS_ERROR_NOT_IMPLEMENTED;
 791 }
 792
 793 NS_IMETHODIMP
 794 NullHttpChannel::GetServerTiming(nsIArray** aServerTiming) {
 795   return NS_ERROR_NOT_IMPLEMENTED;
 796 }
 797
 798 NS_IMETHODIMP
 799 NullHttpChannel::GetNativeServerTiming(
 800     nsTArray<nsCOMPtr<nsIServerTiming>>& aServerTiming) {
 801   return NS_ERROR_NOT_IMPLEMENTED;
 802 }
 803
 804 NS_IMETHODIMP NullHttpChannel::SetClassicScriptHintCharset(
 805     const nsAString& aClassicScriptHintCharset) {
 806   return NS_ERROR_NOT_IMPLEMENTED;
 807 }
 808
 809 NS_IMETHODIMP NullHttpChannel::GetClassicScriptHintCharset(
 810     nsAString& aClassicScriptHintCharset) {
 811   return NS_ERROR_NOT_IMPLEMENTED;
 812 }
 813
 814 NS_IMETHODIMP NullHttpChannel::SetDocumentCharacterSet(
 815     const nsAString& aDocumentCharacterSet) {
 816   return NS_ERROR_NOT_IMPLEMENTED;
 817 }
 818
 819 NS_IMETHODIMP NullHttpChannel::GetDocumentCharacterSet(
 820     nsAString& aDocumentCharacterSet) {
 821   return NS_ERROR_NOT_IMPLEMENTED;
 822 }
 823
 824 #define IMPL_TIMING_ATTR(name)                                           \
 825   NS_IMETHODIMP                                                          \
 826   NullHttpChannel::Get##name##Time(PRTime* _retval) {                    \
 827     TimeStamp stamp;                                                     \
 828     Get##name(&stamp);                                                   \
 829     if (stamp.IsNull()) {                                                \
 830       *_retval = 0;                                                      \
 831       return NS_OK;                                                      \
 832     }                                                                    \
 833     *_retval =                                                           \
 834         mChannelCreationTime +                                           \
 835         (PRTime)((stamp - mChannelCreationTimestamp).ToSeconds() * 1e6); \
 836     return NS_OK;                                                        \
 837   }
 838
 839 IMPL_TIMING_ATTR(ChannelCreation)
 840 IMPL_TIMING_ATTR(AsyncOpen)
 841 IMPL_TIMING_ATTR(LaunchServiceWorkerStart)
 842 IMPL_TIMING_ATTR(LaunchServiceWorkerEnd)
 843 IMPL_TIMING_ATTR(DispatchFetchEventStart)
 844 IMPL_TIMING_ATTR(DispatchFetchEventEnd)
 845 IMPL_TIMING_ATTR(HandleFetchEventStart)
 846 IMPL_TIMING_ATTR(HandleFetchEventEnd)
 847 IMPL_TIMING_ATTR(DomainLookupStart)
 848 IMPL_TIMING_ATTR(DomainLookupEnd)
 849 IMPL_TIMING_ATTR(ConnectStart)
 850 IMPL_TIMING_ATTR(TcpConnectEnd)
 851 IMPL_TIMING_ATTR(SecureConnectionStart)
 852 IMPL_TIMING_ATTR(ConnectEnd)
 853 IMPL_TIMING_ATTR(RequestStart)
 854 IMPL_TIMING_ATTR(ResponseStart)
 855 IMPL_TIMING_ATTR(ResponseEnd)
 856 IMPL_TIMING_ATTR(CacheReadStart)
 857 IMPL_TIMING_ATTR(CacheReadEnd)
 858 IMPL_TIMING_ATTR(RedirectStart)
 859 IMPL_TIMING_ATTR(RedirectEnd)
 860 IMPL_TIMING_ATTR(TransactionPending)
 861
 862 #undef IMPL_TIMING_ATTR
 863
 864 }  // namespace net
 865 }  // namespace mozilla