1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <string> 6 7 #include "base/basictypes.h" 8 #include "base/bind.h" 9 #include "base/compiler_specific.h" 10 #include "base/files/file_path.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "base/memory/weak_ptr.h" 13 #include "base/message_loop/message_loop.h" 14 #include "base/path_service.h" 15 #include "base/strings/stringprintf.h" 16 #include "base/threading/sequenced_worker_pool.h" 17 #include "chrome/browser/ui/browser.h" 18 #include "chrome/browser/ui/tabs/tab_strip_model.h" 19 #include "chrome/common/chrome_paths.h" 20 #include "chrome/test/base/in_process_browser_test.h" 21 #include "chrome/test/base/ui_test_utils.h" 22 #include "content/public/browser/browser_thread.h" 23 #include "content/public/test/browser_test_utils.h" 24 #include "net/base/load_timing_info.h" 25 #include "net/test/spawned_test_server/spawned_test_server.h" 26 #include "net/url_request/url_request_file_job.h" 27 #include "net/url_request/url_request_filter.h" 28 #include "net/url_request/url_request_job_factory.h" 29 #include "url/gurl.h" 30 31 // This file tests that net::LoadTimingInfo is correctly hooked up to the 32 // NavigationTiming API. It depends on behavior in a large number of files 33 // spread across multiple projects, so is somewhat arbitrarily put in 34 // chrome/browser/net. 35 36 using content::BrowserThread; 37 38 namespace { 39 40 const char kTestDomain[] = "test.com"; 41 const char kTestUrl[] = "http://test.com/"; 42 43 // Relative times need to be used because: 44 // 1) ExecuteScriptAndExtractInt does not support 64-bit integers. 45 // 2) Times for tests are set before the request has been started, but need to 46 // be set relative to the start time. 47 // 48 // Since some tests need to test negative time deltas (preconnected sockets) 49 // and others need to test NULL times (events that don't apply), this class has 50 // to be able to handle all cases: positive deltas, negative deltas, no 51 // delta, and null times. 52 class RelativeTime { 53 public: 54 // Constructor for null RelativeTimes. 55 RelativeTime() : is_null_(true) { 56 } 57 58 // Constructor for non-null RelativeTimes. 59 explicit RelativeTime(int delta_ms) 60 : is_null_(false), 61 delta_(base::TimeDelta::FromMilliseconds(delta_ms)) { 62 } 63 64 // Given a base time, returns the TimeTicks |this| identifies. 65 base::TimeTicks ToTimeTicks(base::TimeTicks base_time) const { 66 if (is_null_) 67 return base::TimeTicks(); 68 return base_time + delta_; 69 } 70 71 bool is_null() const { return is_null_; } 72 73 base::TimeDelta GetDelta() const { 74 // This allows tests to compare times that shouldn't be null without 75 // explicitly null-testing them all first. 76 EXPECT_FALSE(is_null_); 77 return delta_; 78 } 79 80 private: 81 bool is_null_; 82 83 // Must be 0 when |is_null| is true. 84 base::TimeDelta delta_; 85 86 // This class is copyable and assignable. 87 }; 88 89 // Structure used for both setting the LoadTimingInfo used by mock requests 90 // and for times retrieved from the renderer process. 91 // 92 // Times used for mock requests are all expressed as TimeDeltas relative to 93 // when the Job starts. Null RelativeTimes correspond to null TimeTicks(). 94 // 95 // Times read from the renderer are expressed relative to fetchStart (Which is 96 // not the same as request_start). Null RelativeTimes correspond to times that 97 // either cannot be retrieved (proxy times, send end) or times that are 0 (SSL 98 // time when no new SSL connection was established). 99 struct TimingDeltas { 100 RelativeTime proxy_resolve_start; 101 RelativeTime proxy_resolve_end; 102 RelativeTime dns_start; 103 RelativeTime dns_end; 104 RelativeTime connect_start; 105 RelativeTime ssl_start; 106 RelativeTime connect_end; 107 RelativeTime send_start; 108 RelativeTime send_end; 109 110 // Must be non-negative and greater than all other times. May only be null if 111 // all other times are as well. 112 RelativeTime receive_headers_end; 113 }; 114 115 // Mock UrlRequestJob that returns the contents of a specified file and 116 // provides the specified load timing information when queried. 117 class MockUrlRequestJobWithTiming : public net::URLRequestFileJob { 118 public: 119 MockUrlRequestJobWithTiming(net::URLRequest* request, 120 net::NetworkDelegate* network_delegate, 121 const base::FilePath& path, 122 const TimingDeltas& load_timing_deltas) 123 : net::URLRequestFileJob( 124 request, network_delegate, path, 125 content::BrowserThread::GetBlockingPool()-> 126 GetTaskRunnerWithShutdownBehavior( 127 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)), 128 load_timing_deltas_(load_timing_deltas), 129 weak_factory_(this) {} 130 131 // net::URLRequestFileJob implementation: 132 virtual void Start() OVERRIDE { 133 base::TimeDelta time_to_wait; 134 start_time_ = base::TimeTicks::Now(); 135 if (!load_timing_deltas_.receive_headers_end.is_null()) { 136 // Need to delay starting until the largest of the times has elapsed. 137 // Wait a little longer than necessary, to be on the safe side. 138 time_to_wait = load_timing_deltas_.receive_headers_end.GetDelta() + 139 base::TimeDelta::FromMilliseconds(100); 140 } 141 142 base::MessageLoop::current()->PostDelayedTask( 143 FROM_HERE, 144 base::Bind(&MockUrlRequestJobWithTiming::DelayedStart, 145 weak_factory_.GetWeakPtr()), 146 time_to_wait); 147 } 148 149 virtual void GetLoadTimingInfo( 150 net::LoadTimingInfo* load_timing_info) const OVERRIDE { 151 // Make sure enough time has elapsed since start was called. If this 152 // fails, the test fixture itself is flaky. 153 if (!load_timing_deltas_.receive_headers_end.is_null()) { 154 EXPECT_LE( 155 start_time_ + load_timing_deltas_.receive_headers_end.GetDelta(), 156 base::TimeTicks::Now()); 157 } 158 159 // If there are no connect times, but there is a receive headers end time, 160 // then assume the socket is reused. This shouldn't affect the load timing 161 // information the test checks, just done for completeness. 162 load_timing_info->socket_reused = false; 163 if (load_timing_deltas_.connect_start.is_null() && 164 !load_timing_deltas_.receive_headers_end.is_null()) { 165 load_timing_info->socket_reused = true; 166 } 167 168 load_timing_info->proxy_resolve_start = 169 load_timing_deltas_.proxy_resolve_start.ToTimeTicks(start_time_); 170 load_timing_info->proxy_resolve_end = 171 load_timing_deltas_.proxy_resolve_end.ToTimeTicks(start_time_); 172 173 load_timing_info->connect_timing.dns_start = 174 load_timing_deltas_.dns_start.ToTimeTicks(start_time_); 175 load_timing_info->connect_timing.dns_end = 176 load_timing_deltas_.dns_end.ToTimeTicks(start_time_); 177 load_timing_info->connect_timing.connect_start = 178 load_timing_deltas_.connect_start.ToTimeTicks(start_time_); 179 load_timing_info->connect_timing.ssl_start = 180 load_timing_deltas_.ssl_start.ToTimeTicks(start_time_); 181 load_timing_info->connect_timing.connect_end = 182 load_timing_deltas_.connect_end.ToTimeTicks(start_time_); 183 184 // If there's an SSL start time, use connect end as the SSL end time. 185 // The NavigationTiming API does not have a corresponding field, and there's 186 // no need to test the case when the values are both non-NULL and different. 187 if (!load_timing_deltas_.ssl_start.is_null()) { 188 load_timing_info->connect_timing.ssl_end = 189 load_timing_info->connect_timing.connect_end; 190 } 191 192 load_timing_info->send_start = 193 load_timing_deltas_.send_start.ToTimeTicks(start_time_); 194 load_timing_info->send_end= 195 load_timing_deltas_.send_end.ToTimeTicks(start_time_); 196 load_timing_info->receive_headers_end = 197 load_timing_deltas_.receive_headers_end.ToTimeTicks(start_time_); 198 } 199 200 private: 201 // Parent class is reference counted, so need to have a private destructor. 202 virtual ~MockUrlRequestJobWithTiming() {} 203 204 void DelayedStart() { 205 net::URLRequestFileJob::Start(); 206 } 207 208 // Load times to use, relative to |start_time_|. 209 const TimingDeltas load_timing_deltas_; 210 base::TimeTicks start_time_; 211 212 base::WeakPtrFactory<MockUrlRequestJobWithTiming> weak_factory_; 213 214 DISALLOW_COPY_AND_ASSIGN(MockUrlRequestJobWithTiming); 215 }; 216 217 // A protocol handler that returns mock URLRequestJobs that return the specified 218 // file with the given timings. Constructed on the UI thread, but after that, 219 // lives and is destroyed on the IO thread. 220 class TestProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler { 221 public: 222 TestProtocolHandler(const base::FilePath& path, 223 const TimingDeltas& load_timing_deltas) 224 : path_(path), load_timing_deltas_(load_timing_deltas) { 225 EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI)); 226 } 227 228 virtual ~TestProtocolHandler() { 229 EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); 230 } 231 232 // Registers |this| with the URLRequestFilter, which takes ownership of it. 233 void Register() { 234 EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); 235 net::URLRequestFilter::GetInstance()->AddHostnameProtocolHandler( 236 "http", kTestDomain, 237 scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(this)); 238 } 239 240 // Unregisters |this| with the URLRequestFilter, which should then delete 241 // |this|. 242 void Unregister() { 243 EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); 244 net::URLRequestFilter::GetInstance()->RemoveHostnameHandler( 245 "http", kTestDomain); 246 } 247 248 // net::URLRequestJobFactory::ProtocolHandler implementation: 249 virtual net::URLRequestJob* MaybeCreateJob( 250 net::URLRequest* request, 251 net::NetworkDelegate* network_delegate) const OVERRIDE { 252 EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); 253 254 return new MockUrlRequestJobWithTiming(request, network_delegate, path_, 255 load_timing_deltas_); 256 } 257 258 private: 259 // Path of the file to use as the response body. 260 const base::FilePath path_; 261 262 // Load times for each request to use, relative to when the Job starts. 263 const TimingDeltas load_timing_deltas_; 264 265 DISALLOW_COPY_AND_ASSIGN(TestProtocolHandler); 266 }; 267 268 class LoadTimingBrowserTest : public InProcessBrowserTest { 269 public: 270 LoadTimingBrowserTest() { 271 } 272 273 virtual ~LoadTimingBrowserTest() { 274 } 275 276 // Navigates to |url| and writes the resulting navigation timings to 277 // |navigation_deltas|. 278 void RunTestWithUrl(const GURL& url, TimingDeltas* navigation_deltas) { 279 ui_test_utils::NavigateToURL(browser(), url); 280 GetResultDeltas(navigation_deltas); 281 } 282 283 // Navigates to a url that returns the timings indicated by 284 // |load_timing_deltas| and writes the resulting navigation timings to 285 // |navigation_deltas|. Uses a generic test page. 286 void RunTest(const TimingDeltas& load_timing_deltas, 287 TimingDeltas* navigation_deltas) { 288 // None of the tests care about the contents of the test page. Just do 289 // this here because PathService has thread restrictions on some platforms. 290 base::FilePath path; 291 PathService::Get(chrome::DIR_TEST_DATA, &path); 292 path = path.AppendASCII("title1.html"); 293 294 // Create and register protocol handler. 295 TestProtocolHandler* protocol_handler = 296 new TestProtocolHandler(path, load_timing_deltas); 297 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, 298 base::Bind(&TestProtocolHandler::Register, 299 base::Unretained(protocol_handler))); 300 301 // Navigate to the page. 302 RunTestWithUrl(GURL(kTestUrl), navigation_deltas); 303 304 // Once navigation is complete, unregister the protocol handler. 305 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, 306 base::Bind(&TestProtocolHandler::Unregister, 307 base::Unretained(protocol_handler))); 308 } 309 310 private: 311 // Reads applicable times from performance.timing and writes them to 312 // |navigation_deltas|. Proxy times and send end cannot be read from the 313 // Navigation Timing API, so those are all left as null. 314 void GetResultDeltas(TimingDeltas* navigation_deltas) { 315 *navigation_deltas = TimingDeltas(); 316 317 navigation_deltas->dns_start = GetResultDelta("domainLookupStart"); 318 navigation_deltas->dns_end = GetResultDelta("domainLookupEnd"); 319 navigation_deltas->connect_start = GetResultDelta("connectStart"); 320 navigation_deltas->connect_end = GetResultDelta("connectEnd"); 321 navigation_deltas->send_start = GetResultDelta("requestStart"); 322 navigation_deltas->receive_headers_end = GetResultDelta("responseStart"); 323 324 // Unlike the above times, secureConnectionStart will be zero when not 325 // applicable. In that case, leave ssl_start as null. 326 bool ssl_start_zero = false; 327 ASSERT_TRUE(content::ExecuteScriptAndExtractBool( 328 browser()->tab_strip_model()->GetActiveWebContents(), 329 "window.domAutomationController.send(" 330 "performance.timing.secureConnectionStart == 0);", 331 &ssl_start_zero)); 332 if (!ssl_start_zero) 333 navigation_deltas->ssl_start = GetResultDelta("secureConnectionStart"); 334 335 // Simple sanity checks. Make sure times that correspond to LoadTimingInfo 336 // occur between fetchStart and loadEventEnd. Relationships between 337 // intervening times are handled by the test bodies. 338 339 RelativeTime fetch_start = GetResultDelta("fetchStart"); 340 // While the input dns_start is sometimes null, when read from the 341 // NavigationTiming API, it's always non-null. 342 EXPECT_LE(fetch_start.GetDelta(), navigation_deltas->dns_start.GetDelta()); 343 344 RelativeTime load_event_end = GetResultDelta("loadEventEnd"); 345 EXPECT_LE(navigation_deltas->receive_headers_end.GetDelta(), 346 load_event_end.GetDelta()); 347 } 348 349 // Returns the time between performance.timing.fetchStart and the time with 350 // the specified name. This time must be non-negative. 351 RelativeTime GetResultDelta(const std::string& name) { 352 int time_ms = 0; 353 std::string command(base::StringPrintf( 354 "window.domAutomationController.send(" 355 "performance.timing.%s - performance.timing.fetchStart);", 356 name.c_str())); 357 EXPECT_TRUE(content::ExecuteScriptAndExtractInt( 358 browser()->tab_strip_model()->GetActiveWebContents(), 359 command.c_str(), 360 &time_ms)); 361 362 // Basic sanity check. 363 EXPECT_GE(time_ms, 0); 364 365 return RelativeTime(time_ms); 366 } 367 }; 368 369 // Test case when no times are given, except the request start times. This 370 // happens with FTP, cached responses, responses handled by something other than 371 // the network stack, RedirectJobs, HSTs, etc. 372 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, NoTimes) { 373 TimingDeltas load_timing_deltas; 374 TimingDeltas navigation_deltas; 375 RunTest(load_timing_deltas, &navigation_deltas); 376 377 // When there are no times, all read times should be the same as fetchStart, 378 // except SSL start, which should be 0. 379 EXPECT_EQ(base::TimeDelta(), navigation_deltas.dns_start.GetDelta()); 380 EXPECT_EQ(base::TimeDelta(), navigation_deltas.dns_end.GetDelta()); 381 EXPECT_EQ(base::TimeDelta(), navigation_deltas.connect_start.GetDelta()); 382 EXPECT_EQ(base::TimeDelta(), navigation_deltas.connect_end.GetDelta()); 383 EXPECT_EQ(base::TimeDelta(), navigation_deltas.send_start.GetDelta()); 384 EXPECT_EQ(base::TimeDelta(), 385 navigation_deltas.receive_headers_end.GetDelta()); 386 387 EXPECT_TRUE(navigation_deltas.ssl_start.is_null()); 388 } 389 390 // Standard case - new socket, no PAC, no preconnect, no SSL. 391 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, Basic) { 392 TimingDeltas load_timing_deltas; 393 load_timing_deltas.dns_start = RelativeTime(0); 394 load_timing_deltas.dns_end = RelativeTime(100); 395 load_timing_deltas.connect_start = RelativeTime(200); 396 load_timing_deltas.connect_end = RelativeTime(300); 397 load_timing_deltas.send_start = RelativeTime(400); 398 load_timing_deltas.send_end = RelativeTime(500); 399 load_timing_deltas.receive_headers_end = RelativeTime(600); 400 401 TimingDeltas navigation_deltas; 402 RunTest(load_timing_deltas, &navigation_deltas); 403 404 // Due to potential roundoff issues, never check exact differences. 405 EXPECT_LT(navigation_deltas.dns_start.GetDelta(), 406 navigation_deltas.dns_end.GetDelta()); 407 EXPECT_LT(navigation_deltas.dns_end.GetDelta(), 408 navigation_deltas.connect_start.GetDelta()); 409 EXPECT_LT(navigation_deltas.connect_start.GetDelta(), 410 navigation_deltas.connect_end.GetDelta()); 411 EXPECT_LT(navigation_deltas.connect_end.GetDelta(), 412 navigation_deltas.send_start.GetDelta()); 413 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 414 navigation_deltas.receive_headers_end.GetDelta()); 415 416 EXPECT_TRUE(navigation_deltas.ssl_start.is_null()); 417 } 418 419 // Basic SSL case. 420 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, Ssl) { 421 TimingDeltas load_timing_deltas; 422 load_timing_deltas.dns_start = RelativeTime(0); 423 load_timing_deltas.dns_end = RelativeTime(100); 424 load_timing_deltas.connect_start = RelativeTime(200); 425 load_timing_deltas.ssl_start = RelativeTime(300); 426 load_timing_deltas.connect_end = RelativeTime(400); 427 load_timing_deltas.send_start = RelativeTime(500); 428 load_timing_deltas.send_end = RelativeTime(600); 429 load_timing_deltas.receive_headers_end = RelativeTime(700); 430 431 TimingDeltas navigation_deltas; 432 RunTest(load_timing_deltas, &navigation_deltas); 433 434 // Due to potential roundoff issues, never check exact differences. 435 EXPECT_LT(navigation_deltas.dns_start.GetDelta(), 436 navigation_deltas.dns_end.GetDelta()); 437 EXPECT_LT(navigation_deltas.dns_end.GetDelta(), 438 navigation_deltas.connect_start.GetDelta()); 439 EXPECT_LT(navigation_deltas.connect_start.GetDelta(), 440 navigation_deltas.ssl_start.GetDelta()); 441 EXPECT_LT(navigation_deltas.ssl_start.GetDelta(), 442 navigation_deltas.connect_end.GetDelta()); 443 EXPECT_LT(navigation_deltas.connect_end.GetDelta(), 444 navigation_deltas.send_start.GetDelta()); 445 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 446 navigation_deltas.receive_headers_end.GetDelta()); 447 } 448 449 // All times are the same. 450 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, EverythingAtOnce) { 451 TimingDeltas load_timing_deltas; 452 load_timing_deltas.dns_start = RelativeTime(100); 453 load_timing_deltas.dns_end = RelativeTime(100); 454 load_timing_deltas.connect_start = RelativeTime(100); 455 load_timing_deltas.ssl_start = RelativeTime(100); 456 load_timing_deltas.connect_end = RelativeTime(100); 457 load_timing_deltas.send_start = RelativeTime(100); 458 load_timing_deltas.send_end = RelativeTime(100); 459 load_timing_deltas.receive_headers_end = RelativeTime(100); 460 461 TimingDeltas navigation_deltas; 462 RunTest(load_timing_deltas, &navigation_deltas); 463 464 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 465 navigation_deltas.dns_end.GetDelta()); 466 EXPECT_EQ(navigation_deltas.dns_end.GetDelta(), 467 navigation_deltas.connect_start.GetDelta()); 468 EXPECT_EQ(navigation_deltas.connect_start.GetDelta(), 469 navigation_deltas.ssl_start.GetDelta()); 470 EXPECT_EQ(navigation_deltas.ssl_start.GetDelta(), 471 navigation_deltas.connect_end.GetDelta()); 472 EXPECT_EQ(navigation_deltas.connect_end.GetDelta(), 473 navigation_deltas.send_start.GetDelta()); 474 EXPECT_EQ(navigation_deltas.send_start.GetDelta(), 475 navigation_deltas.receive_headers_end.GetDelta()); 476 } 477 478 // Reuse case. 479 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, ReuseSocket) { 480 TimingDeltas load_timing_deltas; 481 load_timing_deltas.send_start = RelativeTime(0); 482 load_timing_deltas.send_end = RelativeTime(100); 483 load_timing_deltas.receive_headers_end = RelativeTime(200); 484 485 TimingDeltas navigation_deltas; 486 RunTest(load_timing_deltas, &navigation_deltas); 487 488 // Connect times should all be the same as fetchStart. 489 EXPECT_EQ(base::TimeDelta(), navigation_deltas.dns_start.GetDelta()); 490 EXPECT_EQ(base::TimeDelta(), navigation_deltas.dns_end.GetDelta()); 491 EXPECT_EQ(base::TimeDelta(), navigation_deltas.connect_start.GetDelta()); 492 EXPECT_EQ(base::TimeDelta(), navigation_deltas.connect_end.GetDelta()); 493 494 // Connect end may be less than send start, since connect end defaults to 495 // fetchStart, which is often less than request_start. 496 EXPECT_LE(navigation_deltas.connect_end.GetDelta(), 497 navigation_deltas.send_start.GetDelta()); 498 499 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 500 navigation_deltas.receive_headers_end.GetDelta()); 501 502 EXPECT_TRUE(navigation_deltas.ssl_start.is_null()); 503 } 504 505 // Preconnect case. Connect times are all before the request was started. 506 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, Preconnect) { 507 TimingDeltas load_timing_deltas; 508 load_timing_deltas.dns_start = RelativeTime(-1000300); 509 load_timing_deltas.dns_end = RelativeTime(-1000200); 510 load_timing_deltas.connect_start = RelativeTime(-1000100); 511 load_timing_deltas.connect_end = RelativeTime(-1000000); 512 load_timing_deltas.send_start = RelativeTime(0); 513 load_timing_deltas.send_end = RelativeTime(100); 514 load_timing_deltas.receive_headers_end = RelativeTime(200); 515 516 TimingDeltas navigation_deltas; 517 RunTest(load_timing_deltas, &navigation_deltas); 518 519 // Connect times should all be the same as request_start. 520 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 521 navigation_deltas.dns_end.GetDelta()); 522 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 523 navigation_deltas.connect_start.GetDelta()); 524 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 525 navigation_deltas.connect_end.GetDelta()); 526 527 EXPECT_LE(navigation_deltas.dns_start.GetDelta(), 528 navigation_deltas.send_start.GetDelta()); 529 530 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 531 navigation_deltas.receive_headers_end.GetDelta()); 532 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 533 navigation_deltas.receive_headers_end.GetDelta()); 534 535 EXPECT_TRUE(navigation_deltas.ssl_start.is_null()); 536 } 537 538 // Preconnect case with a proxy. Connect times are all before the proxy lookup 539 // finished (Or at the same time). 540 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, PreconnectProxySsl) { 541 TimingDeltas load_timing_deltas; 542 load_timing_deltas.proxy_resolve_start = RelativeTime(0); 543 load_timing_deltas.proxy_resolve_end = RelativeTime(100); 544 load_timing_deltas.dns_start = RelativeTime(-3000000); 545 load_timing_deltas.dns_end = RelativeTime(-2000000); 546 load_timing_deltas.connect_start = RelativeTime(-1000000); 547 load_timing_deltas.ssl_start = RelativeTime(0); 548 load_timing_deltas.connect_end = RelativeTime(100); 549 load_timing_deltas.send_start = RelativeTime(100); 550 load_timing_deltas.send_end = RelativeTime(200); 551 load_timing_deltas.receive_headers_end = RelativeTime(300); 552 553 TimingDeltas navigation_deltas; 554 RunTest(load_timing_deltas, &navigation_deltas); 555 556 // Connect times should all be the same as proxy_end, which is also the 557 // same as send_start. 558 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 559 navigation_deltas.dns_end.GetDelta()); 560 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 561 navigation_deltas.connect_start.GetDelta()); 562 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 563 navigation_deltas.ssl_start.GetDelta()); 564 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 565 navigation_deltas.connect_end.GetDelta()); 566 EXPECT_EQ(navigation_deltas.dns_start.GetDelta(), 567 navigation_deltas.send_start.GetDelta()); 568 569 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 570 navigation_deltas.receive_headers_end.GetDelta()); 571 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 572 navigation_deltas.receive_headers_end.GetDelta()); 573 } 574 575 // Integration test with a real network response. 576 IN_PROC_BROWSER_TEST_F(LoadTimingBrowserTest, Integration) { 577 ASSERT_TRUE(test_server()->Start()); 578 TimingDeltas navigation_deltas; 579 RunTestWithUrl(test_server()->GetURL("chunked?waitBeforeHeaders=100"), 580 &navigation_deltas); 581 582 // Due to potential roundoff issues, never check exact differences. 583 EXPECT_LE(navigation_deltas.dns_start.GetDelta(), 584 navigation_deltas.dns_end.GetDelta()); 585 EXPECT_LE(navigation_deltas.dns_end.GetDelta(), 586 navigation_deltas.connect_start.GetDelta()); 587 EXPECT_LE(navigation_deltas.connect_start.GetDelta(), 588 navigation_deltas.connect_end.GetDelta()); 589 EXPECT_LE(navigation_deltas.connect_end.GetDelta(), 590 navigation_deltas.send_start.GetDelta()); 591 // The only times that are guaranteed to be distinct are send_start and 592 // received_headers_end. 593 EXPECT_LT(navigation_deltas.send_start.GetDelta(), 594 navigation_deltas.receive_headers_end.GetDelta()); 595 596 EXPECT_TRUE(navigation_deltas.ssl_start.is_null()); 597 } 598 599 } // namespace 600
