src/third_party/WebKit/Source/platform/network/ResourceResponse.cpp

   1 /*
   2  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
   3  * Copyright (C) 2009 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "platform/network/ResourceResponse.h"
  29
  30 #include "wtf/CurrentTime.h"
  31 #include "wtf/StdLibExtras.h"
  32
  33 namespace blink {
  34
  35 ResourceResponse::ResourceResponse()
  36     : m_expectedContentLength(0)
  37     , m_httpStatusCode(0)
  38     , m_lastModifiedDate(0)
  39     , m_wasCached(false)
  40     , m_connectionID(0)
  41     , m_connectionReused(false)
  42     , m_isNull(true)
  43     , m_haveParsedAgeHeader(false)
  44     , m_haveParsedDateHeader(false)
  45     , m_haveParsedExpiresHeader(false)
  46     , m_haveParsedLastModifiedHeader(false)
  47     , m_age(0.0)
  48     , m_date(0.0)
  49     , m_expires(0.0)
  50     , m_lastModified(0.0)
  51     , m_httpVersion(Unknown)
  52     , m_appCacheID(0)
  53     , m_isMultipartPayload(false)
  54     , m_wasFetchedViaSPDY(false)
  55     , m_wasNpnNegotiated(false)
  56     , m_wasAlternateProtocolAvailable(false)
  57     , m_wasFetchedViaProxy(false)
  58     , m_wasFetchedViaServiceWorker(false)
  59     , m_wasFallbackRequiredByServiceWorker(false)
  60     , m_serviceWorkerResponseType(WebServiceWorkerResponseTypeDefault)
  61     , m_responseTime(0)
  62     , m_remotePort(0)
  63 {
  64 }
  65
  66 ResourceResponse::ResourceResponse(const KURL& url, const AtomicString& mimeType, long long expectedLength, const AtomicString& textEncodingName, const String& filename)
  67     : m_url(url)
  68     , m_mimeType(mimeType)
  69     , m_expectedContentLength(expectedLength)
  70     , m_textEncodingName(textEncodingName)
  71     , m_suggestedFilename(filename)
  72     , m_httpStatusCode(0)
  73     , m_lastModifiedDate(0)
  74     , m_wasCached(false)
  75     , m_connectionID(0)
  76     , m_connectionReused(false)
  77     , m_isNull(false)
  78     , m_haveParsedAgeHeader(false)
  79     , m_haveParsedDateHeader(false)
  80     , m_haveParsedExpiresHeader(false)
  81     , m_haveParsedLastModifiedHeader(false)
  82     , m_age(0.0)
  83     , m_date(0.0)
  84     , m_expires(0.0)
  85     , m_lastModified(0.0)
  86     , m_httpVersion(Unknown)
  87     , m_appCacheID(0)
  88     , m_isMultipartPayload(false)
  89     , m_wasFetchedViaSPDY(false)
  90     , m_wasNpnNegotiated(false)
  91     , m_wasAlternateProtocolAvailable(false)
  92     , m_wasFetchedViaProxy(false)
  93     , m_wasFetchedViaServiceWorker(false)
  94     , m_wasFallbackRequiredByServiceWorker(false)
  95     , m_serviceWorkerResponseType(WebServiceWorkerResponseTypeDefault)
  96     , m_responseTime(0)
  97     , m_remotePort(0)
  98 {
  99 }
 100
 101 PassOwnPtr<ResourceResponse> ResourceResponse::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)
 102 {
 103     OwnPtr<ResourceResponse> response = adoptPtr(new ResourceResponse);
 104     response->setURL(data->m_url);
 105     response->setMimeType(AtomicString(data->m_mimeType));
 106     response->setExpectedContentLength(data->m_expectedContentLength);
 107     response->setTextEncodingName(AtomicString(data->m_textEncodingName));
 108     response->setSuggestedFilename(data->m_suggestedFilename);
 109
 110     response->setHTTPStatusCode(data->m_httpStatusCode);
 111     response->setHTTPStatusText(AtomicString(data->m_httpStatusText));
 112
 113     response->m_httpHeaderFields.adopt(data->m_httpHeaders.release());
 114     response->setLastModifiedDate(data->m_lastModifiedDate);
 115     response->setResourceLoadTiming(data->m_resourceLoadTiming.release());
 116     response->m_securityInfo = data->m_securityInfo;
 117     response->m_httpVersion = data->m_httpVersion;
 118     response->m_appCacheID = data->m_appCacheID;
 119     response->m_appCacheManifestURL = data->m_appCacheManifestURL.copy();
 120     response->m_isMultipartPayload = data->m_isMultipartPayload;
 121     response->m_wasFetchedViaSPDY = data->m_wasFetchedViaSPDY;
 122     response->m_wasNpnNegotiated = data->m_wasNpnNegotiated;
 123     response->m_wasAlternateProtocolAvailable = data->m_wasAlternateProtocolAvailable;
 124     response->m_wasFetchedViaProxy = data->m_wasFetchedViaProxy;
 125     response->m_wasFetchedViaServiceWorker = data->m_wasFetchedViaServiceWorker;
 126     response->m_wasFallbackRequiredByServiceWorker = data->m_wasFallbackRequiredByServiceWorker;
 127     response->m_serviceWorkerResponseType = data->m_serviceWorkerResponseType;
 128     response->m_responseTime = data->m_responseTime;
 129     response->m_remoteIPAddress = AtomicString(data->m_remoteIPAddress);
 130     response->m_remotePort = data->m_remotePort;
 131     response->m_downloadedFilePath = data->m_downloadedFilePath;
 132     response->m_downloadedFileHandle = data->m_downloadedFileHandle;
 133
 134     // Bug https://bugs.webkit.org/show_bug.cgi?id=60397 this doesn't support
 135     // whatever values may be present in the opaque m_extraData structure.
 136
 137     return response.release();
 138 }
 139
 140 PassOwnPtr<CrossThreadResourceResponseData> ResourceResponse::copyData() const
 141 {
 142     OwnPtr<CrossThreadResourceResponseData> data = adoptPtr(new CrossThreadResourceResponseData);
 143     data->m_url = url().copy();
 144     data->m_mimeType = mimeType().string().isolatedCopy();
 145     data->m_expectedContentLength = expectedContentLength();
 146     data->m_textEncodingName = textEncodingName().string().isolatedCopy();
 147     data->m_suggestedFilename = suggestedFilename().isolatedCopy();
 148     data->m_httpStatusCode = httpStatusCode();
 149     data->m_httpStatusText = httpStatusText().string().isolatedCopy();
 150     data->m_httpHeaders = httpHeaderFields().copyData();
 151     data->m_lastModifiedDate = lastModifiedDate();
 152     if (m_resourceLoadTiming)
 153         data->m_resourceLoadTiming = m_resourceLoadTiming->deepCopy();
 154     data->m_securityInfo = CString(m_securityInfo.data(), m_securityInfo.length());
 155     data->m_httpVersion = m_httpVersion;
 156     data->m_appCacheID = m_appCacheID;
 157     data->m_appCacheManifestURL = m_appCacheManifestURL.copy();
 158     data->m_isMultipartPayload = m_isMultipartPayload;
 159     data->m_wasFetchedViaSPDY = m_wasFetchedViaSPDY;
 160     data->m_wasNpnNegotiated = m_wasNpnNegotiated;
 161     data->m_wasAlternateProtocolAvailable = m_wasAlternateProtocolAvailable;
 162     data->m_wasFetchedViaProxy = m_wasFetchedViaProxy;
 163     data->m_wasFetchedViaServiceWorker = m_wasFetchedViaServiceWorker;
 164     data->m_wasFallbackRequiredByServiceWorker = m_wasFallbackRequiredByServiceWorker;
 165     data->m_serviceWorkerResponseType = m_serviceWorkerResponseType;
 166     data->m_responseTime = m_responseTime;
 167     data->m_remoteIPAddress = m_remoteIPAddress.string().isolatedCopy();
 168     data->m_remotePort = m_remotePort;
 169     data->m_downloadedFilePath = m_downloadedFilePath.isolatedCopy();
 170     data->m_downloadedFileHandle = m_downloadedFileHandle;
 171
 172     // Bug https://bugs.webkit.org/show_bug.cgi?id=60397 this doesn't support
 173     // whatever values may be present in the opaque m_extraData structure.
 174
 175     return data.release();
 176 }
 177
 178 bool ResourceResponse::isHTTP() const
 179 {
 180     return m_url.protocolIsInHTTPFamily();
 181 }
 182
 183 const KURL& ResourceResponse::url() const
 184 {
 185     return m_url;
 186 }
 187
 188 void ResourceResponse::setURL(const KURL& url)
 189 {
 190     m_isNull = false;
 191
 192     m_url = url;
 193 }
 194
 195 const AtomicString& ResourceResponse::mimeType() const
 196 {
 197     return m_mimeType;
 198 }
 199
 200 void ResourceResponse::setMimeType(const AtomicString& mimeType)
 201 {
 202     m_isNull = false;
 203
 204     // FIXME: MIME type is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_mimeType.
 205     m_mimeType = mimeType;
 206 }
 207
 208 long long ResourceResponse::expectedContentLength() const
 209 {
 210     return m_expectedContentLength;
 211 }
 212
 213 void ResourceResponse::setExpectedContentLength(long long expectedContentLength)
 214 {
 215     m_isNull = false;
 216
 217     // FIXME: Content length is determined by HTTP Content-Length header. We should update the header, so that it doesn't disagree with m_expectedContentLength.
 218     m_expectedContentLength = expectedContentLength;
 219 }
 220
 221 const AtomicString& ResourceResponse::textEncodingName() const
 222 {
 223     return m_textEncodingName;
 224 }
 225
 226 void ResourceResponse::setTextEncodingName(const AtomicString& encodingName)
 227 {
 228     m_isNull = false;
 229
 230     // FIXME: Text encoding is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_textEncodingName.
 231     m_textEncodingName = encodingName;
 232 }
 233
 234 // FIXME should compute this on the fly
 235 const String& ResourceResponse::suggestedFilename() const
 236 {
 237     return m_suggestedFilename;
 238 }
 239
 240 void ResourceResponse::setSuggestedFilename(const String& suggestedName)
 241 {
 242     m_isNull = false;
 243
 244     // FIXME: Suggested file name is calculated based on other headers. There should not be a setter for it.
 245     m_suggestedFilename = suggestedName;
 246 }
 247
 248 int ResourceResponse::httpStatusCode() const
 249 {
 250     return m_httpStatusCode;
 251 }
 252
 253 void ResourceResponse::setHTTPStatusCode(int statusCode)
 254 {
 255     m_httpStatusCode = statusCode;
 256 }
 257
 258 const AtomicString& ResourceResponse::httpStatusText() const
 259 {
 260     return m_httpStatusText;
 261 }
 262
 263 void ResourceResponse::setHTTPStatusText(const AtomicString& statusText)
 264 {
 265     m_httpStatusText = statusText;
 266 }
 267
 268 const AtomicString& ResourceResponse::httpHeaderField(const AtomicString& name) const
 269 {
 270     return m_httpHeaderFields.get(name);
 271 }
 272
 273 const AtomicString& ResourceResponse::httpHeaderField(const char* name) const
 274 {
 275     return m_httpHeaderFields.get(name);
 276 }
 277
 278 static const AtomicString& cacheControlHeaderString()
 279 {
 280     DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control", AtomicString::ConstructFromLiteral));
 281     return cacheControlHeader;
 282 }
 283
 284 static const AtomicString& pragmaHeaderString()
 285 {
 286     DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma", AtomicString::ConstructFromLiteral));
 287     return pragmaHeader;
 288 }
 289
 290 void ResourceResponse::updateHeaderParsedState(const AtomicString& name)
 291 {
 292     DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age", AtomicString::ConstructFromLiteral));
 293     DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date", AtomicString::ConstructFromLiteral));
 294     DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires", AtomicString::ConstructFromLiteral));
 295     DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified", AtomicString::ConstructFromLiteral));
 296
 297     if (equalIgnoringCase(name, ageHeader))
 298         m_haveParsedAgeHeader = false;
 299     else if (equalIgnoringCase(name, cacheControlHeaderString()) || equalIgnoringCase(name, pragmaHeaderString()))
 300         m_cacheControlHeader = CacheControlHeader();
 301     else if (equalIgnoringCase(name, dateHeader))
 302         m_haveParsedDateHeader = false;
 303     else if (equalIgnoringCase(name, expiresHeader))
 304         m_haveParsedExpiresHeader = false;
 305     else if (equalIgnoringCase(name, lastModifiedHeader))
 306         m_haveParsedLastModifiedHeader = false;
 307 }
 308
 309 void ResourceResponse::setHTTPHeaderField(const AtomicString& name, const AtomicString& value)
 310 {
 311     updateHeaderParsedState(name);
 312
 313     m_httpHeaderFields.set(name, value);
 314 }
 315
 316 void ResourceResponse::addHTTPHeaderField(const AtomicString& name, const AtomicString& value)
 317 {
 318     updateHeaderParsedState(name);
 319
 320     HTTPHeaderMap::AddResult result = m_httpHeaderFields.add(name, value);
 321     if (!result.isNewEntry)
 322         result.storedValue->value = result.storedValue->value + ", " + value;
 323 }
 324
 325 void ResourceResponse::clearHTTPHeaderField(const AtomicString& name)
 326 {
 327     m_httpHeaderFields.remove(name);
 328 }
 329
 330 const HTTPHeaderMap& ResourceResponse::httpHeaderFields() const
 331 {
 332     return m_httpHeaderFields;
 333 }
 334
 335 bool ResourceResponse::cacheControlContainsNoCache()
 336 {
 337     if (!m_cacheControlHeader.parsed)
 338         m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
 339     return m_cacheControlHeader.containsNoCache;
 340 }
 341
 342 bool ResourceResponse::cacheControlContainsNoStore()
 343 {
 344     if (!m_cacheControlHeader.parsed)
 345         m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
 346     return m_cacheControlHeader.containsNoStore;
 347 }
 348
 349 bool ResourceResponse::cacheControlContainsMustRevalidate()
 350 {
 351     if (!m_cacheControlHeader.parsed)
 352         m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
 353     return m_cacheControlHeader.containsMustRevalidate;
 354 }
 355
 356 bool ResourceResponse::hasCacheValidatorFields() const
 357 {
 358     DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified", AtomicString::ConstructFromLiteral));
 359     DEFINE_STATIC_LOCAL(const AtomicString, eTagHeader, ("etag", AtomicString::ConstructFromLiteral));
 360     return !m_httpHeaderFields.get(lastModifiedHeader).isEmpty() || !m_httpHeaderFields.get(eTagHeader).isEmpty();
 361 }
 362
 363 double ResourceResponse::cacheControlMaxAge()
 364 {
 365     if (!m_cacheControlHeader.parsed)
 366         m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
 367     return m_cacheControlHeader.maxAge;
 368 }
 369
 370 static double parseDateValueInHeader(const HTTPHeaderMap& headers, const AtomicString& headerName)
 371 {
 372     const AtomicString& headerValue = headers.get(headerName);
 373     if (headerValue.isEmpty())
 374         return std::numeric_limits<double>::quiet_NaN();
 375     // This handles all date formats required by RFC2616:
 376     // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
 377     // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
 378     // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
 379     double dateInMilliseconds = parseDate(headerValue);
 380     if (!std::isfinite(dateInMilliseconds))
 381         return std::numeric_limits<double>::quiet_NaN();
 382     return dateInMilliseconds / 1000;
 383 }
 384
 385 double ResourceResponse::date() const
 386 {
 387     if (!m_haveParsedDateHeader) {
 388         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date", AtomicString::ConstructFromLiteral));
 389         m_date = parseDateValueInHeader(m_httpHeaderFields, headerName);
 390         m_haveParsedDateHeader = true;
 391     }
 392     return m_date;
 393 }
 394
 395 double ResourceResponse::age() const
 396 {
 397     if (!m_haveParsedAgeHeader) {
 398         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age", AtomicString::ConstructFromLiteral));
 399         const AtomicString& headerValue = m_httpHeaderFields.get(headerName);
 400         bool ok;
 401         m_age = headerValue.toDouble(&ok);
 402         if (!ok)
 403             m_age = std::numeric_limits<double>::quiet_NaN();
 404         m_haveParsedAgeHeader = true;
 405     }
 406     return m_age;
 407 }
 408
 409 double ResourceResponse::expires() const
 410 {
 411     if (!m_haveParsedExpiresHeader) {
 412         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires", AtomicString::ConstructFromLiteral));
 413         m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName);
 414         m_haveParsedExpiresHeader = true;
 415     }
 416     return m_expires;
 417 }
 418
 419 double ResourceResponse::lastModified() const
 420 {
 421     if (!m_haveParsedLastModifiedHeader) {
 422         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified", AtomicString::ConstructFromLiteral));
 423         m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName);
 424         m_haveParsedLastModifiedHeader = true;
 425     }
 426     return m_lastModified;
 427 }
 428
 429 bool ResourceResponse::isAttachment() const
 430 {
 431     DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition", AtomicString::ConstructFromLiteral));
 432     String value = m_httpHeaderFields.get(headerName);
 433     size_t loc = value.find(';');
 434     if (loc != kNotFound)
 435         value = value.left(loc);
 436     value = value.stripWhiteSpace();
 437     DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment", AtomicString::ConstructFromLiteral));
 438     return equalIgnoringCase(value, attachmentString);
 439 }
 440
 441 void ResourceResponse::setLastModifiedDate(time_t lastModifiedDate)
 442 {
 443     m_lastModifiedDate = lastModifiedDate;
 444 }
 445
 446 time_t ResourceResponse::lastModifiedDate() const
 447 {
 448     return m_lastModifiedDate;
 449 }
 450
 451 bool ResourceResponse::wasCached() const
 452 {
 453     return m_wasCached;
 454 }
 455
 456 void ResourceResponse::setWasCached(bool value)
 457 {
 458     m_wasCached = value;
 459 }
 460
 461 bool ResourceResponse::connectionReused() const
 462 {
 463     return m_connectionReused;
 464 }
 465
 466 void ResourceResponse::setConnectionReused(bool connectionReused)
 467 {
 468     m_connectionReused = connectionReused;
 469 }
 470
 471 unsigned ResourceResponse::connectionID() const
 472 {
 473     return m_connectionID;
 474 }
 475
 476 void ResourceResponse::setConnectionID(unsigned connectionID)
 477 {
 478     m_connectionID = connectionID;
 479 }
 480
 481 ResourceLoadTiming* ResourceResponse::resourceLoadTiming() const
 482 {
 483     return m_resourceLoadTiming.get();
 484 }
 485
 486 void ResourceResponse::setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming)
 487 {
 488     m_resourceLoadTiming = resourceLoadTiming;
 489 }
 490
 491 PassRefPtr<ResourceLoadInfo> ResourceResponse::resourceLoadInfo() const
 492 {
 493     return m_resourceLoadInfo.get();
 494 }
 495
 496 void ResourceResponse::setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo)
 497 {
 498     m_resourceLoadInfo = loadInfo;
 499 }
 500
 501 void ResourceResponse::setDownloadedFilePath(const String& downloadedFilePath)
 502 {
 503     m_downloadedFilePath = downloadedFilePath;
 504     if (m_downloadedFilePath.isEmpty()) {
 505         m_downloadedFileHandle.clear();
 506         return;
 507     }
 508     OwnPtr<BlobData> blobData = BlobData::create();
 509     blobData->appendFile(m_downloadedFilePath);
 510     blobData->detachFromCurrentThread();
 511     m_downloadedFileHandle = BlobDataHandle::create(blobData.release(), -1);
 512 }
 513
 514 bool ResourceResponse::compare(const ResourceResponse& a, const ResourceResponse& b)
 515 {
 516     if (a.isNull() != b.isNull())
 517         return false;
 518     if (a.url() != b.url())
 519         return false;
 520     if (a.mimeType() != b.mimeType())
 521         return false;
 522     if (a.expectedContentLength() != b.expectedContentLength())
 523         return false;
 524     if (a.textEncodingName() != b.textEncodingName())
 525         return false;
 526     if (a.suggestedFilename() != b.suggestedFilename())
 527         return false;
 528     if (a.httpStatusCode() != b.httpStatusCode())
 529         return false;
 530     if (a.httpStatusText() != b.httpStatusText())
 531         return false;
 532     if (a.httpHeaderFields() != b.httpHeaderFields())
 533         return false;
 534     if (a.resourceLoadTiming() && b.resourceLoadTiming() && *a.resourceLoadTiming() == *b.resourceLoadTiming())
 535         return true;
 536     if (a.resourceLoadTiming() != b.resourceLoadTiming())
 537         return false;
 538     return true;
 539 }
 540
 541 }