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::GetRequestObserversCalled(bool* aCalled) {
 251   return NS_ERROR_NOT_IMPLEMENTED;
 252 }
 253
 254 NS_IMETHODIMP
 255 NullHttpChannel::SetRequestObserversCalled(bool aCalled) {
 256   return NS_ERROR_NOT_IMPLEMENTED;
 257 }
 258
 259 NS_IMETHODIMP
 260 NullHttpChannel::GetRequestContextID(uint64_t* _retval) {
 261   return NS_ERROR_NOT_IMPLEMENTED;
 262 }
 263
 264 NS_IMETHODIMP
 265 NullHttpChannel::SetRequestContextID(uint64_t rcID) {
 266   return NS_ERROR_NOT_IMPLEMENTED;
 267 }
 268
 269 NS_IMETHODIMP
 270 NullHttpChannel::GetProtocolVersion(nsACString& aProtocolVersion) {
 271   return NS_ERROR_NOT_IMPLEMENTED;
 272 }
 273
 274 NS_IMETHODIMP
 275 NullHttpChannel::GetEncodedBodySize(uint64_t* aEncodedBodySize) {
 276   return NS_ERROR_NOT_IMPLEMENTED;
 277 }
 278
 279 void NullHttpChannel::SetSource(
 280     mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource) {}
 281
 282 //-----------------------------------------------------------------------------
 283 // NullHttpChannel::nsIChannel
 284 //-----------------------------------------------------------------------------
 285
 286 NS_IMETHODIMP
 287 NullHttpChannel::GetOriginalURI(nsIURI** aOriginalURI) {
 288   *aOriginalURI = do_AddRef(mOriginalURI).take();
 289   return NS_OK;
 290 }
 291
 292 NS_IMETHODIMP
 293 NullHttpChannel::SetOriginalURI(nsIURI* aOriginalURI) {
 294   mOriginalURI = aOriginalURI;
 295   return NS_OK;
 296 }
 297
 298 NS_IMETHODIMP
 299 NullHttpChannel::GetURI(nsIURI** aURI) {
 300   *aURI = do_AddRef(mURI).take();
 301   return NS_OK;
 302 }
 303
 304 NS_IMETHODIMP
 305 NullHttpChannel::GetOwner(nsISupports** aOwner) {
 306   return NS_ERROR_NOT_IMPLEMENTED;
 307 }
 308
 309 NS_IMETHODIMP
 310 NullHttpChannel::SetOwner(nsISupports* aOwner) {
 311   return NS_ERROR_NOT_IMPLEMENTED;
 312 }
 313
 314 NS_IMETHODIMP
 315 NullHttpChannel::GetNotificationCallbacks(
 316     nsIInterfaceRequestor** aNotificationCallbacks) {
 317   return NS_ERROR_NOT_IMPLEMENTED;
 318 }
 319
 320 NS_IMETHODIMP
 321 NullHttpChannel::SetNotificationCallbacks(
 322     nsIInterfaceRequestor* aNotificationCallbacks) {
 323   return NS_ERROR_NOT_IMPLEMENTED;
 324 }
 325
 326 NS_IMETHODIMP
 327 NullHttpChannel::GetSecurityInfo(nsITransportSecurityInfo** aSecurityInfo) {
 328   return NS_ERROR_NOT_IMPLEMENTED;
 329 }
 330
 331 NS_IMETHODIMP
 332 NullHttpChannel::GetContentType(nsACString& aContentType) {
 333   return NS_ERROR_NOT_IMPLEMENTED;
 334 }
 335
 336 NS_IMETHODIMP
 337 NullHttpChannel::SetContentType(const nsACString& aContentType) {
 338   return NS_ERROR_NOT_IMPLEMENTED;
 339 }
 340
 341 NS_IMETHODIMP
 342 NullHttpChannel::GetContentCharset(nsACString& aContentCharset) {
 343   return NS_ERROR_NOT_IMPLEMENTED;
 344 }
 345
 346 NS_IMETHODIMP
 347 NullHttpChannel::SetContentCharset(const nsACString& aContentCharset) {
 348   return NS_ERROR_NOT_IMPLEMENTED;
 349 }
 350
 351 NS_IMETHODIMP
 352 NullHttpChannel::GetContentLength(int64_t* aContentLength) {
 353   return NS_ERROR_NOT_IMPLEMENTED;
 354 }
 355
 356 NS_IMETHODIMP
 357 NullHttpChannel::SetContentLength(int64_t aContentLength) {
 358   return NS_ERROR_NOT_IMPLEMENTED;
 359 }
 360
 361 NS_IMETHODIMP
 362 NullHttpChannel::Open(nsIInputStream** aStream) {
 363   nsCOMPtr<nsIStreamListener> listener;
 364   nsresult rv =
 365       nsContentSecurityManager::doContentSecurityCheck(this, listener);
 366   NS_ENSURE_SUCCESS(rv, rv);
 367
 368   return NS_ERROR_NOT_IMPLEMENTED;
 369 }
 370
 371 NS_IMETHODIMP
 372 NullHttpChannel::AsyncOpen(nsIStreamListener* aListener) {
 373   nsCOMPtr<nsIStreamListener> listener = aListener;
 374   nsresult rv =
 375       nsContentSecurityManager::doContentSecurityCheck(this, listener);
 376   NS_ENSURE_SUCCESS(rv, rv);
 377   return NS_ERROR_NOT_IMPLEMENTED;
 378 }
 379
 380 NS_IMETHODIMP
 381 NullHttpChannel::GetContentDisposition(uint32_t* aContentDisposition) {
 382   return NS_ERROR_NOT_IMPLEMENTED;
 383 }
 384
 385 NS_IMETHODIMP
 386 NullHttpChannel::SetContentDisposition(uint32_t aContentDisposition) {
 387   return NS_ERROR_NOT_IMPLEMENTED;
 388 }
 389
 390 NS_IMETHODIMP
 391 NullHttpChannel::GetContentDispositionFilename(
 392     nsAString& aContentDispositionFilename) {
 393   return NS_ERROR_NOT_IMPLEMENTED;
 394 }
 395
 396 NS_IMETHODIMP
 397 NullHttpChannel::SetContentDispositionFilename(
 398     const nsAString& aContentDispositionFilename) {
 399   return NS_ERROR_NOT_IMPLEMENTED;
 400 }
 401
 402 NS_IMETHODIMP
 403 NullHttpChannel::GetContentDispositionHeader(
 404     nsACString& aContentDispositionHeader) {
 405   return NS_ERROR_NOT_IMPLEMENTED;
 406 }
 407
 408 NS_IMETHODIMP
 409 NullHttpChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) {
 410   return NS_ERROR_NOT_IMPLEMENTED;
 411 }
 412
 413 NS_IMETHODIMP
 414 NullHttpChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) {
 415   return NS_ERROR_NOT_IMPLEMENTED;
 416 }
 417
 418 //-----------------------------------------------------------------------------
 419 // NullHttpChannel::nsIRequest
 420 //-----------------------------------------------------------------------------
 421
 422 NS_IMETHODIMP
 423 NullHttpChannel::GetName(nsACString& aName) { return NS_ERROR_NOT_IMPLEMENTED; }
 424
 425 NS_IMETHODIMP
 426 NullHttpChannel::IsPending(bool* _retval) { return NS_ERROR_NOT_IMPLEMENTED; }
 427
 428 NS_IMETHODIMP
 429 NullHttpChannel::GetStatus(nsresult* aStatus) {
 430   return NS_ERROR_NOT_IMPLEMENTED;
 431 }
 432
 433 NS_IMETHODIMP NullHttpChannel::SetCanceledReason(const nsACString& aReason) {
 434   return NS_ERROR_NOT_IMPLEMENTED;
 435 }
 436
 437 NS_IMETHODIMP NullHttpChannel::GetCanceledReason(nsACString& aReason) {
 438   return NS_ERROR_NOT_IMPLEMENTED;
 439 }
 440
 441 NS_IMETHODIMP NullHttpChannel::CancelWithReason(nsresult aStatus,
 442                                                 const nsACString& aReason) {
 443   return NS_ERROR_NOT_IMPLEMENTED;
 444 }
 445
 446 NS_IMETHODIMP
 447 NullHttpChannel::Cancel(nsresult aStatus) { return NS_ERROR_NOT_IMPLEMENTED; }
 448
 449 NS_IMETHODIMP
 450 NullHttpChannel::GetCanceled(bool* aCanceled) {
 451   return NS_ERROR_NOT_IMPLEMENTED;
 452 }
 453
 454 NS_IMETHODIMP
 455 NullHttpChannel::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; }
 456
 457 NS_IMETHODIMP
 458 NullHttpChannel::Resume() { return NS_ERROR_NOT_IMPLEMENTED; }
 459
 460 NS_IMETHODIMP
 461 NullHttpChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
 462   return NS_ERROR_NOT_IMPLEMENTED;
 463 }
 464
 465 NS_IMETHODIMP
 466 NullHttpChannel::SetLoadGroup(nsILoadGroup* aLoadGroup) {
 467   return NS_ERROR_NOT_IMPLEMENTED;
 468 }
 469
 470 NS_IMETHODIMP
 471 NullHttpChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
 472   return NS_ERROR_NOT_IMPLEMENTED;
 473 }
 474
 475 NS_IMETHODIMP
 476 NullHttpChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
 477   return NS_ERROR_NOT_IMPLEMENTED;
 478 }
 479
 480 NS_IMETHODIMP
 481 NullHttpChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
 482   return NS_ERROR_NOT_IMPLEMENTED;
 483 }
 484
 485 NS_IMETHODIMP
 486 NullHttpChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
 487   return NS_ERROR_NOT_IMPLEMENTED;
 488 }
 489
 490 NS_IMETHODIMP
 491 NullHttpChannel::GetIsDocument(bool* aIsDocument) {
 492   return NS_ERROR_NOT_IMPLEMENTED;
 493 }
 494
 495 //-----------------------------------------------------------------------------
 496 // NullHttpChannel::nsITimedChannel
 497 //-----------------------------------------------------------------------------
 498
 499 NS_IMETHODIMP
 500 NullHttpChannel::GetTimingEnabled(bool* aTimingEnabled) {
 501   // We don't want to report timing for null channels.
 502   *aTimingEnabled = false;
 503   return NS_OK;
 504 }
 505
 506 NS_IMETHODIMP
 507 NullHttpChannel::SetTimingEnabled(bool aTimingEnabled) {
 508   return NS_ERROR_NOT_IMPLEMENTED;
 509 }
 510
 511 NS_IMETHODIMP
 512 NullHttpChannel::GetRedirectCount(uint8_t* aRedirectCount) {
 513   return NS_ERROR_NOT_IMPLEMENTED;
 514 }
 515
 516 NS_IMETHODIMP
 517 NullHttpChannel::SetRedirectCount(uint8_t aRedirectCount) {
 518   return NS_ERROR_NOT_IMPLEMENTED;
 519 }
 520
 521 NS_IMETHODIMP
 522 NullHttpChannel::GetInternalRedirectCount(uint8_t* aRedirectCount) {
 523   return NS_ERROR_NOT_IMPLEMENTED;
 524 }
 525
 526 NS_IMETHODIMP
 527 NullHttpChannel::SetInternalRedirectCount(uint8_t aRedirectCount) {
 528   return NS_ERROR_NOT_IMPLEMENTED;
 529 }
 530
 531 NS_IMETHODIMP
 532 NullHttpChannel::GetChannelCreation(mozilla::TimeStamp* aChannelCreation) {
 533   *aChannelCreation = mChannelCreationTimestamp;
 534   return NS_OK;
 535 }
 536
 537 NS_IMETHODIMP
 538 NullHttpChannel::SetChannelCreation(TimeStamp aValue) {
 539   MOZ_DIAGNOSTIC_ASSERT(!aValue.IsNull());
 540   TimeDuration adjust = aValue - mChannelCreationTimestamp;
 541   mChannelCreationTimestamp = aValue;
 542   mChannelCreationTime += (PRTime)adjust.ToMicroseconds();
 543   return NS_OK;
 544 }
 545
 546 NS_IMETHODIMP
 547 NullHttpChannel::GetAsyncOpen(mozilla::TimeStamp* aAsyncOpen) {
 548   *aAsyncOpen = mAsyncOpenTime;
 549   return NS_OK;
 550 }
 551
 552 NS_IMETHODIMP
 553 NullHttpChannel::SetAsyncOpen(TimeStamp aValue) {
 554   MOZ_DIAGNOSTIC_ASSERT(!aValue.IsNull());
 555   mAsyncOpenTime = aValue;
 556   return NS_OK;
 557 }
 558
 559 NS_IMETHODIMP
 560 NullHttpChannel::GetLaunchServiceWorkerStart(mozilla::TimeStamp* _retval) {
 561   MOZ_ASSERT(_retval);
 562   *_retval = mAsyncOpenTime;
 563   return NS_OK;
 564 }
 565
 566 NS_IMETHODIMP
 567 NullHttpChannel::SetLaunchServiceWorkerStart(mozilla::TimeStamp aTimeStamp) {
 568   return NS_OK;
 569 }
 570
 571 NS_IMETHODIMP
 572 NullHttpChannel::GetLaunchServiceWorkerEnd(mozilla::TimeStamp* _retval) {
 573   MOZ_ASSERT(_retval);
 574   *_retval = mAsyncOpenTime;
 575   return NS_OK;
 576 }
 577
 578 NS_IMETHODIMP
 579 NullHttpChannel::SetLaunchServiceWorkerEnd(mozilla::TimeStamp aTimeStamp) {
 580   return NS_OK;
 581 }
 582
 583 NS_IMETHODIMP
 584 NullHttpChannel::GetDispatchFetchEventStart(mozilla::TimeStamp* _retval) {
 585   MOZ_ASSERT(_retval);
 586   *_retval = mAsyncOpenTime;
 587   return NS_OK;
 588 }
 589
 590 NS_IMETHODIMP
 591 NullHttpChannel::SetDispatchFetchEventStart(mozilla::TimeStamp aTimeStamp) {
 592   return NS_OK;
 593 }
 594
 595 NS_IMETHODIMP
 596 NullHttpChannel::GetDispatchFetchEventEnd(mozilla::TimeStamp* _retval) {
 597   MOZ_ASSERT(_retval);
 598   *_retval = mAsyncOpenTime;
 599   return NS_OK;
 600 }
 601
 602 NS_IMETHODIMP
 603 NullHttpChannel::SetDispatchFetchEventEnd(mozilla::TimeStamp aTimeStamp) {
 604   return NS_OK;
 605 }
 606
 607 NS_IMETHODIMP
 608 NullHttpChannel::GetHandleFetchEventStart(mozilla::TimeStamp* _retval) {
 609   MOZ_ASSERT(_retval);
 610   *_retval = mAsyncOpenTime;
 611   return NS_OK;
 612 }
 613
 614 NS_IMETHODIMP
 615 NullHttpChannel::SetHandleFetchEventStart(mozilla::TimeStamp aTimeStamp) {
 616   return NS_OK;
 617 }
 618
 619 NS_IMETHODIMP
 620 NullHttpChannel::GetHandleFetchEventEnd(mozilla::TimeStamp* _retval) {
 621   MOZ_ASSERT(_retval);
 622   *_retval = mAsyncOpenTime;
 623   return NS_OK;
 624 }
 625
 626 NS_IMETHODIMP
 627 NullHttpChannel::SetHandleFetchEventEnd(mozilla::TimeStamp aTimeStamp) {
 628   return NS_OK;
 629 }
 630
 631 NS_IMETHODIMP
 632 NullHttpChannel::GetDomainLookupStart(mozilla::TimeStamp* aDomainLookupStart) {
 633   *aDomainLookupStart = mAsyncOpenTime;
 634   return NS_OK;
 635 }
 636
 637 NS_IMETHODIMP
 638 NullHttpChannel::GetDomainLookupEnd(mozilla::TimeStamp* aDomainLookupEnd) {
 639   *aDomainLookupEnd = mAsyncOpenTime;
 640   return NS_OK;
 641 }
 642
 643 NS_IMETHODIMP
 644 NullHttpChannel::GetConnectStart(mozilla::TimeStamp* aConnectStart) {
 645   *aConnectStart = mAsyncOpenTime;
 646   return NS_OK;
 647 }
 648
 649 NS_IMETHODIMP
 650 NullHttpChannel::GetTcpConnectEnd(mozilla::TimeStamp* aTcpConnectEnd) {
 651   *aTcpConnectEnd = mAsyncOpenTime;
 652   return NS_OK;
 653 }
 654
 655 NS_IMETHODIMP
 656 NullHttpChannel::GetSecureConnectionStart(
 657     mozilla::TimeStamp* aSecureConnectionStart) {
 658   *aSecureConnectionStart = mAsyncOpenTime;
 659   return NS_OK;
 660 }
 661
 662 NS_IMETHODIMP
 663 NullHttpChannel::GetConnectEnd(mozilla::TimeStamp* aConnectEnd) {
 664   *aConnectEnd = mAsyncOpenTime;
 665   return NS_OK;
 666 }
 667
 668 NS_IMETHODIMP
 669 NullHttpChannel::GetRequestStart(mozilla::TimeStamp* aRequestStart) {
 670   *aRequestStart = mAsyncOpenTime;
 671   return NS_OK;
 672 }
 673
 674 NS_IMETHODIMP
 675 NullHttpChannel::GetResponseStart(mozilla::TimeStamp* aResponseStart) {
 676   *aResponseStart = mAsyncOpenTime;
 677   return NS_OK;
 678 }
 679
 680 NS_IMETHODIMP
 681 NullHttpChannel::GetResponseEnd(mozilla::TimeStamp* aResponseEnd) {
 682   *aResponseEnd = mAsyncOpenTime;
 683   return NS_OK;
 684 }
 685
 686 NS_IMETHODIMP
 687 NullHttpChannel::GetRedirectStart(mozilla::TimeStamp* aRedirectStart) {
 688   *aRedirectStart = mAsyncOpenTime;
 689   return NS_OK;
 690 }
 691
 692 NS_IMETHODIMP
 693 NullHttpChannel::SetRedirectStart(mozilla::TimeStamp aRedirectStart) {
 694   return NS_ERROR_NOT_IMPLEMENTED;
 695 }
 696
 697 NS_IMETHODIMP
 698 NullHttpChannel::GetRedirectEnd(mozilla::TimeStamp* aRedirectEnd) {
 699   *aRedirectEnd = mAsyncOpenTime;
 700   return NS_OK;
 701 }
 702
 703 NS_IMETHODIMP
 704 NullHttpChannel::SetRedirectEnd(mozilla::TimeStamp aRedirectEnd) {
 705   return NS_ERROR_NOT_IMPLEMENTED;
 706 }
 707
 708 NS_IMETHODIMP
 709 NullHttpChannel::GetInitiatorType(nsAString& aInitiatorType) {
 710   aInitiatorType = mInitiatorType;
 711   return NS_OK;
 712 }
 713
 714 NS_IMETHODIMP
 715 NullHttpChannel::SetInitiatorType(const nsAString& aInitiatorType) {
 716   mInitiatorType = aInitiatorType;
 717   return NS_OK;
 718 }
 719
 720 NS_IMETHODIMP
 721 NullHttpChannel::GetAllRedirectsSameOrigin(bool* aAllRedirectsSameOrigin) {
 722   *aAllRedirectsSameOrigin = mAllRedirectsSameOrigin;
 723   return NS_OK;
 724 }
 725
 726 NS_IMETHODIMP
 727 NullHttpChannel::SetAllRedirectsSameOrigin(bool aAllRedirectsSameOrigin) {
 728   return NS_ERROR_NOT_IMPLEMENTED;
 729 }
 730
 731 NS_IMETHODIMP
 732 NullHttpChannel::GetAllRedirectsPassTimingAllowCheck(
 733     bool* aAllRedirectsPassTimingAllowCheck) {
 734   *aAllRedirectsPassTimingAllowCheck = mAllRedirectsPassTimingAllowCheck;
 735   return NS_OK;
 736 }
 737
 738 NS_IMETHODIMP
 739 NullHttpChannel::SetAllRedirectsPassTimingAllowCheck(
 740     bool aAllRedirectsPassTimingAllowCheck) {
 741   return NS_ERROR_NOT_IMPLEMENTED;
 742 }
 743
 744 NS_IMETHODIMP
 745 NullHttpChannel::BodyInfoAccessAllowedCheck(nsIPrincipal* aOrigin,
 746                                             BodyInfoAccess* _retval) {
 747   *_retval = BodyInfoAccess::DISALLOWED;
 748   return NS_OK;
 749 }
 750
 751 NS_IMETHODIMP
 752 NullHttpChannel::TimingAllowCheck(nsIPrincipal* aOrigin, bool* _retval) {
 753   *_retval = false;
 754   return NS_OK;
 755 }
 756
 757 NS_IMETHODIMP
 758 NullHttpChannel::GetCacheReadStart(mozilla::TimeStamp* aCacheReadStart) {
 759   *aCacheReadStart = mAsyncOpenTime;
 760   return NS_OK;
 761 }
 762
 763 NS_IMETHODIMP
 764 NullHttpChannel::GetCacheReadEnd(mozilla::TimeStamp* aCacheReadEnd) {
 765   *aCacheReadEnd = mAsyncOpenTime;
 766   return NS_OK;
 767 }
 768
 769 NS_IMETHODIMP
 770 NullHttpChannel::GetTransactionPending(mozilla::TimeStamp* aRetVal) {
 771   *aRetVal = mAsyncOpenTime;
 772   return NS_OK;
 773 }
 774
 775 NS_IMETHODIMP
 776 NullHttpChannel::GetIsMainDocumentChannel(bool* aValue) {
 777   *aValue = false;
 778   return NS_OK;
 779 }
 780
 781 NS_IMETHODIMP
 782 NullHttpChannel::SetIsMainDocumentChannel(bool aValue) {
 783   return NS_ERROR_NOT_IMPLEMENTED;
 784 }
 785
 786 NS_IMETHODIMP
 787 NullHttpChannel::LogBlockedCORSRequest(const nsAString& aMessage,
 788                                        const nsACString& aCategor,
 789                                        bool aIsWarning) {
 790   return NS_ERROR_NOT_IMPLEMENTED;
 791 }
 792
 793 NS_IMETHODIMP
 794 NullHttpChannel::LogMimeTypeMismatch(const nsACString& aMessageName,
 795                                      bool aWarning, const nsAString& aURL,
 796                                      const nsAString& aContentType) {
 797   return NS_ERROR_NOT_IMPLEMENTED;
 798 }
 799
 800 NS_IMETHODIMP
 801 NullHttpChannel::SetReportResourceTiming(bool enabled) {
 802   return NS_ERROR_NOT_IMPLEMENTED;
 803 }
 804
 805 NS_IMETHODIMP
 806 NullHttpChannel::GetReportResourceTiming(bool* _retval) {
 807   return NS_ERROR_NOT_IMPLEMENTED;
 808 }
 809
 810 NS_IMETHODIMP
 811 NullHttpChannel::GetServerTiming(nsIArray** aServerTiming) {
 812   return NS_ERROR_NOT_IMPLEMENTED;
 813 }
 814
 815 NS_IMETHODIMP
 816 NullHttpChannel::GetNativeServerTiming(
 817     nsTArray<nsCOMPtr<nsIServerTiming>>& aServerTiming) {
 818   return NS_ERROR_NOT_IMPLEMENTED;
 819 }
 820
 821 NS_IMETHODIMP NullHttpChannel::SetClassicScriptHintCharset(
 822     const nsAString& aClassicScriptHintCharset) {
 823   return NS_ERROR_NOT_IMPLEMENTED;
 824 }
 825
 826 NS_IMETHODIMP NullHttpChannel::GetClassicScriptHintCharset(
 827     nsAString& aClassicScriptHintCharset) {
 828   return NS_ERROR_NOT_IMPLEMENTED;
 829 }
 830
 831 NS_IMETHODIMP NullHttpChannel::SetDocumentCharacterSet(
 832     const nsAString& aDocumentCharacterSet) {
 833   return NS_ERROR_NOT_IMPLEMENTED;
 834 }
 835
 836 NS_IMETHODIMP NullHttpChannel::GetDocumentCharacterSet(
 837     nsAString& aDocumentCharacterSet) {
 838   return NS_ERROR_NOT_IMPLEMENTED;
 839 }
 840
 841 NS_IMETHODIMP
 842 NullHttpChannel::SetRenderBlocking(bool aRenderBlocking) {
 843   return NS_ERROR_NOT_IMPLEMENTED;
 844 }
 845
 846 NS_IMETHODIMP
 847 NullHttpChannel::GetRenderBlocking(bool* aRenderBlocking) {
 848   return NS_ERROR_NOT_IMPLEMENTED;
 849 }
 850
 851 #define IMPL_TIMING_ATTR(name)                                           \
 852   NS_IMETHODIMP                                                          \
 853   NullHttpChannel::Get##name##Time(PRTime* _retval) {                    \
 854     TimeStamp stamp;                                                     \
 855     Get##name(&stamp);                                                   \
 856     if (stamp.IsNull()) {                                                \
 857       *_retval = 0;                                                      \
 858       return NS_OK;                                                      \
 859     }                                                                    \
 860     *_retval =                                                           \
 861         mChannelCreationTime +                                           \
 862         (PRTime)((stamp - mChannelCreationTimestamp).ToSeconds() * 1e6); \
 863     return NS_OK;                                                        \
 864   }
 865
 866 IMPL_TIMING_ATTR(ChannelCreation)
 867 IMPL_TIMING_ATTR(AsyncOpen)
 868 IMPL_TIMING_ATTR(LaunchServiceWorkerStart)
 869 IMPL_TIMING_ATTR(LaunchServiceWorkerEnd)
 870 IMPL_TIMING_ATTR(DispatchFetchEventStart)
 871 IMPL_TIMING_ATTR(DispatchFetchEventEnd)
 872 IMPL_TIMING_ATTR(HandleFetchEventStart)
 873 IMPL_TIMING_ATTR(HandleFetchEventEnd)
 874 IMPL_TIMING_ATTR(DomainLookupStart)
 875 IMPL_TIMING_ATTR(DomainLookupEnd)
 876 IMPL_TIMING_ATTR(ConnectStart)
 877 IMPL_TIMING_ATTR(TcpConnectEnd)
 878 IMPL_TIMING_ATTR(SecureConnectionStart)
 879 IMPL_TIMING_ATTR(ConnectEnd)
 880 IMPL_TIMING_ATTR(RequestStart)
 881 IMPL_TIMING_ATTR(ResponseStart)
 882 IMPL_TIMING_ATTR(ResponseEnd)
 883 IMPL_TIMING_ATTR(CacheReadStart)
 884 IMPL_TIMING_ATTR(CacheReadEnd)
 885 IMPL_TIMING_ATTR(RedirectStart)
 886 IMPL_TIMING_ATTR(RedirectEnd)
 887 IMPL_TIMING_ATTR(TransactionPending)
 888
 889 #undef IMPL_TIMING_ATTR
 890
 891 }  // namespace net
 892 }  // namespace mozilla