| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 2010 Google Inc. All rights reserved. | |
| 3 * | |
| 4 * Redistribution and use in source and binary forms, with or without | |
| 5 * modification, are permitted provided that the following conditions are | |
| 6 * met: | |
| 7 * | |
| 8 * * Redistributions of source code must retain the above copyright | |
| 9 * notice, this list of conditions and the following disclaimer. | |
| 10 * * Redistributions in binary form must reproduce the above | |
| 11 * copyright notice, this list of conditions and the following disclaimer | |
| 12 * in the documentation and/or other materials provided with the | |
| 13 * distribution. | |
| 14 * * Neither the name of Google Inc. nor the names of its | |
| 15 * contributors may be used to endorse or promote products derived from | |
| 16 * this software without specific prior written permission. | |
| 17 * | |
| 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 */ | |
| 30 | |
| 31 #include "config.h" | |
| 32 #include "core/page/PerformanceTiming.h" | |
| 33 | |
| 34 #include "core/dom/Document.h" | |
| 35 #include "core/dom/DocumentTiming.h" | |
| 36 #include "core/loader/DocumentLoadTiming.h" | |
| 37 #include "core/loader/DocumentLoader.h" | |
| 38 #include "core/loader/FrameLoader.h" | |
| 39 #include "core/page/Frame.h" | |
| 40 #include "core/platform/network/ResourceLoadTiming.h" | |
| 41 #include "core/platform/network/ResourceResponse.h" | |
| 42 | |
| 43 namespace WebCore { | |
| 44 | |
| 45 static unsigned long long toIntegerMilliseconds(double seconds) | |
| 46 { | |
| 47 ASSERT(seconds >= 0); | |
| 48 return static_cast<unsigned long long>(seconds * 1000.0); | |
| 49 } | |
| 50 | |
| 51 PerformanceTiming::PerformanceTiming(Frame* frame) | |
| 52 : DOMWindowProperty(frame) | |
| 53 { | |
| 54 ScriptWrappable::init(this); | |
| 55 } | |
| 56 | |
| 57 unsigned long long PerformanceTiming::navigationStart() const | |
| 58 { | |
| 59 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 60 if (!timing) | |
| 61 return 0; | |
| 62 | |
| 63 return monotonicTimeToIntegerMilliseconds(timing->navigationStart()); | |
| 64 } | |
| 65 | |
| 66 unsigned long long PerformanceTiming::unloadEventStart() const | |
| 67 { | |
| 68 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 69 if (!timing) | |
| 70 return 0; | |
| 71 | |
| 72 if (timing->hasCrossOriginRedirect() || !timing->hasSameOriginAsPreviousDocu
ment()) | |
| 73 return 0; | |
| 74 | |
| 75 return monotonicTimeToIntegerMilliseconds(timing->unloadEventStart()); | |
| 76 } | |
| 77 | |
| 78 unsigned long long PerformanceTiming::unloadEventEnd() const | |
| 79 { | |
| 80 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 81 if (!timing) | |
| 82 return 0; | |
| 83 | |
| 84 if (timing->hasCrossOriginRedirect() || !timing->hasSameOriginAsPreviousDocu
ment()) | |
| 85 return 0; | |
| 86 | |
| 87 return monotonicTimeToIntegerMilliseconds(timing->unloadEventEnd()); | |
| 88 } | |
| 89 | |
| 90 unsigned long long PerformanceTiming::redirectStart() const | |
| 91 { | |
| 92 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 93 if (!timing) | |
| 94 return 0; | |
| 95 | |
| 96 if (timing->hasCrossOriginRedirect()) | |
| 97 return 0; | |
| 98 | |
| 99 return monotonicTimeToIntegerMilliseconds(timing->redirectStart()); | |
| 100 } | |
| 101 | |
| 102 unsigned long long PerformanceTiming::redirectEnd() const | |
| 103 { | |
| 104 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 105 if (!timing) | |
| 106 return 0; | |
| 107 | |
| 108 if (timing->hasCrossOriginRedirect()) | |
| 109 return 0; | |
| 110 | |
| 111 return monotonicTimeToIntegerMilliseconds(timing->redirectEnd()); | |
| 112 } | |
| 113 | |
| 114 unsigned long long PerformanceTiming::fetchStart() const | |
| 115 { | |
| 116 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 117 if (!timing) | |
| 118 return 0; | |
| 119 | |
| 120 return monotonicTimeToIntegerMilliseconds(timing->fetchStart()); | |
| 121 } | |
| 122 | |
| 123 unsigned long long PerformanceTiming::domainLookupStart() const | |
| 124 { | |
| 125 ResourceLoadTiming* timing = resourceLoadTiming(); | |
| 126 if (!timing) | |
| 127 return fetchStart(); | |
| 128 | |
| 129 // This will be zero when a DNS request is not performed. | |
| 130 // Rather than exposing a special value that indicates no DNS, we "backfill"
with fetchStart. | |
| 131 double dnsStart = timing->dnsStart; | |
| 132 if (dnsStart == 0.0) | |
| 133 return fetchStart(); | |
| 134 | |
| 135 return monotonicTimeToIntegerMilliseconds(dnsStart); | |
| 136 } | |
| 137 | |
| 138 unsigned long long PerformanceTiming::domainLookupEnd() const | |
| 139 { | |
| 140 ResourceLoadTiming* timing = resourceLoadTiming(); | |
| 141 if (!timing) | |
| 142 return domainLookupStart(); | |
| 143 | |
| 144 // This will be zero when a DNS request is not performed. | |
| 145 // Rather than exposing a special value that indicates no DNS, we "backfill"
with domainLookupStart. | |
| 146 double dnsEnd = timing->dnsEnd; | |
| 147 if (dnsEnd == 0.0) | |
| 148 return domainLookupStart(); | |
| 149 | |
| 150 return monotonicTimeToIntegerMilliseconds(dnsEnd); | |
| 151 } | |
| 152 | |
| 153 unsigned long long PerformanceTiming::connectStart() const | |
| 154 { | |
| 155 DocumentLoader* loader = documentLoader(); | |
| 156 if (!loader) | |
| 157 return domainLookupEnd(); | |
| 158 | |
| 159 ResourceLoadTiming* timing = loader->response().resourceLoadTiming(); | |
| 160 if (!timing) | |
| 161 return domainLookupEnd(); | |
| 162 | |
| 163 // connectStart will be zero when a network request is not made. | |
| 164 // Rather than exposing a special value that indicates no new connection, we
"backfill" with domainLookupEnd. | |
| 165 double connectStart = timing->connectStart; | |
| 166 if (connectStart == 0.0 || loader->response().connectionReused()) | |
| 167 return domainLookupEnd(); | |
| 168 | |
| 169 // ResourceLoadTiming's connect phase includes DNS, however Navigation Timin
g's | |
| 170 // connect phase should not. So if there is DNS time, trim it from the start
. | |
| 171 if (timing->dnsEnd > 0.0 && timing->dnsEnd > connectStart) | |
| 172 connectStart = timing->dnsEnd; | |
| 173 | |
| 174 return monotonicTimeToIntegerMilliseconds(connectStart); | |
| 175 } | |
| 176 | |
| 177 unsigned long long PerformanceTiming::connectEnd() const | |
| 178 { | |
| 179 DocumentLoader* loader = documentLoader(); | |
| 180 if (!loader) | |
| 181 return connectStart(); | |
| 182 | |
| 183 ResourceLoadTiming* timing = loader->response().resourceLoadTiming(); | |
| 184 if (!timing) | |
| 185 return connectStart(); | |
| 186 | |
| 187 // connectEnd will be zero when a network request is not made. | |
| 188 // Rather than exposing a special value that indicates no new connection, we
"backfill" with connectStart. | |
| 189 double connectEnd = timing->connectEnd; | |
| 190 if (connectEnd == 0.0 || loader->response().connectionReused()) | |
| 191 return connectStart(); | |
| 192 | |
| 193 return monotonicTimeToIntegerMilliseconds(connectEnd); | |
| 194 } | |
| 195 | |
| 196 unsigned long long PerformanceTiming::secureConnectionStart() const | |
| 197 { | |
| 198 DocumentLoader* loader = documentLoader(); | |
| 199 if (!loader) | |
| 200 return 0; | |
| 201 | |
| 202 ResourceLoadTiming* timing = loader->response().resourceLoadTiming(); | |
| 203 if (!timing) | |
| 204 return 0; | |
| 205 | |
| 206 double sslStart = timing->sslStart; | |
| 207 if (sslStart == 0.0) | |
| 208 return 0; | |
| 209 | |
| 210 return monotonicTimeToIntegerMilliseconds(sslStart); | |
| 211 } | |
| 212 | |
| 213 unsigned long long PerformanceTiming::requestStart() const | |
| 214 { | |
| 215 ResourceLoadTiming* timing = resourceLoadTiming(); | |
| 216 | |
| 217 if (!timing || timing->sendStart == 0.0) | |
| 218 return connectEnd(); | |
| 219 | |
| 220 return monotonicTimeToIntegerMilliseconds(timing->sendStart); | |
| 221 } | |
| 222 | |
| 223 unsigned long long PerformanceTiming::responseStart() const | |
| 224 { | |
| 225 ResourceLoadTiming* timing = resourceLoadTiming(); | |
| 226 if (!timing || timing->receiveHeadersEnd == 0.0) | |
| 227 return requestStart(); | |
| 228 | |
| 229 // FIXME: Response start needs to be the time of the first received byte. | |
| 230 // However, the ResourceLoadTiming API currently only supports the time | |
| 231 // the last header byte was received. For many responses with reasonable | |
| 232 // sized cookies, the HTTP headers fit into a single packet so this time | |
| 233 // is basically equivalent. But for some responses, particularly those with | |
| 234 // headers larger than a single packet, this time will be too late. | |
| 235 return monotonicTimeToIntegerMilliseconds(timing->receiveHeadersEnd); | |
| 236 } | |
| 237 | |
| 238 unsigned long long PerformanceTiming::responseEnd() const | |
| 239 { | |
| 240 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 241 if (!timing) | |
| 242 return 0; | |
| 243 | |
| 244 return monotonicTimeToIntegerMilliseconds(timing->responseEnd()); | |
| 245 } | |
| 246 | |
| 247 unsigned long long PerformanceTiming::domLoading() const | |
| 248 { | |
| 249 const DocumentTiming* timing = documentTiming(); | |
| 250 if (!timing) | |
| 251 return fetchStart(); | |
| 252 | |
| 253 return monotonicTimeToIntegerMilliseconds(timing->domLoading); | |
| 254 } | |
| 255 | |
| 256 unsigned long long PerformanceTiming::domInteractive() const | |
| 257 { | |
| 258 const DocumentTiming* timing = documentTiming(); | |
| 259 if (!timing) | |
| 260 return 0; | |
| 261 | |
| 262 return monotonicTimeToIntegerMilliseconds(timing->domInteractive); | |
| 263 } | |
| 264 | |
| 265 unsigned long long PerformanceTiming::domContentLoadedEventStart() const | |
| 266 { | |
| 267 const DocumentTiming* timing = documentTiming(); | |
| 268 if (!timing) | |
| 269 return 0; | |
| 270 | |
| 271 return monotonicTimeToIntegerMilliseconds(timing->domContentLoadedEventStart
); | |
| 272 } | |
| 273 | |
| 274 unsigned long long PerformanceTiming::domContentLoadedEventEnd() const | |
| 275 { | |
| 276 const DocumentTiming* timing = documentTiming(); | |
| 277 if (!timing) | |
| 278 return 0; | |
| 279 | |
| 280 return monotonicTimeToIntegerMilliseconds(timing->domContentLoadedEventEnd); | |
| 281 } | |
| 282 | |
| 283 unsigned long long PerformanceTiming::domComplete() const | |
| 284 { | |
| 285 const DocumentTiming* timing = documentTiming(); | |
| 286 if (!timing) | |
| 287 return 0; | |
| 288 | |
| 289 return monotonicTimeToIntegerMilliseconds(timing->domComplete); | |
| 290 } | |
| 291 | |
| 292 unsigned long long PerformanceTiming::loadEventStart() const | |
| 293 { | |
| 294 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 295 if (!timing) | |
| 296 return 0; | |
| 297 | |
| 298 return monotonicTimeToIntegerMilliseconds(timing->loadEventStart()); | |
| 299 } | |
| 300 | |
| 301 unsigned long long PerformanceTiming::loadEventEnd() const | |
| 302 { | |
| 303 DocumentLoadTiming* timing = documentLoadTiming(); | |
| 304 if (!timing) | |
| 305 return 0; | |
| 306 | |
| 307 return monotonicTimeToIntegerMilliseconds(timing->loadEventEnd()); | |
| 308 } | |
| 309 | |
| 310 DocumentLoader* PerformanceTiming::documentLoader() const | |
| 311 { | |
| 312 if (!m_frame) | |
| 313 return 0; | |
| 314 | |
| 315 return m_frame->loader()->documentLoader(); | |
| 316 } | |
| 317 | |
| 318 const DocumentTiming* PerformanceTiming::documentTiming() const | |
| 319 { | |
| 320 if (!m_frame) | |
| 321 return 0; | |
| 322 | |
| 323 Document* document = m_frame->document(); | |
| 324 if (!document) | |
| 325 return 0; | |
| 326 | |
| 327 return document->timing(); | |
| 328 } | |
| 329 | |
| 330 DocumentLoadTiming* PerformanceTiming::documentLoadTiming() const | |
| 331 { | |
| 332 DocumentLoader* loader = documentLoader(); | |
| 333 if (!loader) | |
| 334 return 0; | |
| 335 | |
| 336 return loader->timing(); | |
| 337 } | |
| 338 | |
| 339 ResourceLoadTiming* PerformanceTiming::resourceLoadTiming() const | |
| 340 { | |
| 341 DocumentLoader* loader = documentLoader(); | |
| 342 if (!loader) | |
| 343 return 0; | |
| 344 | |
| 345 return loader->response().resourceLoadTiming(); | |
| 346 } | |
| 347 | |
| 348 unsigned long long PerformanceTiming::monotonicTimeToIntegerMilliseconds(double
monotonicSeconds) const | |
| 349 { | |
| 350 ASSERT(monotonicSeconds >= 0); | |
| 351 const DocumentLoadTiming* timing = documentLoadTiming(); | |
| 352 ASSERT(timing); | |
| 353 return toIntegerMilliseconds(timing->monotonicTimeToPseudoWallTime(monotonic
Seconds)); | |
| 354 } | |
| 355 | |
| 356 } // namespace WebCore | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 26848007:
Move Navigation Timing and other various window-level objects out of page/ (Closed)
Base URL: svn://svn.chromium.org/blink/trunk