New TimeToFirstURLJob* navigation metrics now work with PlzNavigate.

content/browser/loader/navigation_url_loader_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "content/browser/frame_host/navigation_request_info.h"
@@ skipping 44 matching lines @@
 
  private:
   StreamRegistry* registry_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamProtocolHandler);
 };
 
 class TestNavigationURLLoaderDelegate : public NavigationURLLoaderDelegate {
  public:
   TestNavigationURLLoaderDelegate()
-      : net_error_(0) {
-  }
+      : net_error_(0), on_request_handled_counter_(0) {}
 
   const net::RedirectInfo& redirect_info() const { return redirect_info_; }
   ResourceResponse* redirect_response() const {
     return redirect_response_.get();
   }
   ResourceResponse* response() const { return response_.get(); }
   StreamHandle* body() const { return body_.get(); }
   int net_error() const { return net_error_; }
+  int on_request_handled_counter() const { return on_request_handled_counter_; }
 
   void WaitForRequestRedirected() {
     request_redirected_.reset(new base::RunLoop);
     request_redirected_->Run();
     request_redirected_.reset();
   }
 
   void WaitForResponseStarted() {
     response_started_.reset(new base::RunLoop);
     response_started_->Run();
@@ skipping 27 matching lines @@
     ASSERT_TRUE(response_started_);
     response_started_->Quit();
   }
 
   void OnRequestFailed(int net_error) override {
     net_error_ = net_error;
     ASSERT_TRUE(request_failed_);
     request_failed_->Quit();
   }
 
+  void OnRequestStarted(base::TimeTicks timestamp) override {
+    ASSERT_FALSE(timestamp.is_null());
+    ++on_request_handled_counter_;
+  }
+
  private:
   net::RedirectInfo redirect_info_;
   scoped_refptr<ResourceResponse> redirect_response_;
   scoped_refptr<ResourceResponse> response_;
   scoped_ptr<StreamHandle> body_;
   int net_error_;
+  int on_request_handled_counter_;
 
   scoped_ptr<base::RunLoop> request_redirected_;
   scoped_ptr<base::RunLoop> response_started_;
   scoped_ptr<base::RunLoop> request_failed_;
 };
 
 class RequestBlockingResourceDispatcherHostDelegate
     : public ResourceDispatcherHostDelegate {
  public:
   // ResourceDispatcherHostDelegate implementation:
@@ skipping 77 matching lines @@
   // Wait for the response to come back.
   delegate.WaitForResponseStarted();
 
   // Check the response is correct.
   EXPECT_EQ("text/html", delegate.response()->head.mime_type);
   EXPECT_EQ(200, delegate.response()->head.headers->response_code());
 
   // Check the body is correct.
   EXPECT_EQ(net::URLRequestTestJob::test_data_1(),
             FetchURL(delegate.body()->GetURL()));
+
+  EXPECT_EQ(1, delegate.on_request_handled_counter());
 }
 
 // Tests that request failures are propagated correctly.
 TEST_F(NavigationURLLoaderTest, RequestFailed) {
   TestNavigationURLLoaderDelegate delegate;
   scoped_ptr<NavigationURLLoader> loader =
       MakeTestLoader(GURL("bogus:bogus"), &delegate);
 
   // Wait for the request to fail as expected.
   delegate.WaitForRequestFailed();
   EXPECT_EQ(net::ERR_UNKNOWN_URL_SCHEME, delegate.net_error());
+  EXPECT_EQ(1, delegate.on_request_handled_counter());
 }
 
 // Test that redirects are sent to the delegate.
 TEST_F(NavigationURLLoaderTest, RequestRedirected) {
   // Fake a top-level request. Choose a URL which redirects so the request can
   // be paused before the response comes in.
   TestNavigationURLLoaderDelegate delegate;
   scoped_ptr<NavigationURLLoader> loader =
       MakeTestLoader(net::URLRequestTestJob::test_url_redirect_to_url_2(),
                      &delegate);
 
   // Wait for the request to redirect.
   delegate.WaitForRequestRedirected();
   EXPECT_EQ(net::URLRequestTestJob::test_url_2(),
             delegate.redirect_info().new_url);
   EXPECT_EQ("GET", delegate.redirect_info().new_method);
   EXPECT_EQ(net::URLRequestTestJob::test_url_2(),
             delegate.redirect_info().new_first_party_for_cookies);
   EXPECT_EQ(302, delegate.redirect_response()->head.headers->response_code());
+  EXPECT_EQ(1, delegate.on_request_handled_counter());
 
   // Wait for the response to complete.
   loader->FollowRedirect();
   delegate.WaitForResponseStarted();
 
   // Check the response is correct.
   EXPECT_EQ("text/html", delegate.response()->head.mime_type);
   EXPECT_EQ(200, delegate.response()->head.headers->response_code());
 
   // Release the body and check it is correct.
   EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
   EXPECT_EQ(net::URLRequestTestJob::test_data_2(),
             FetchURL(delegate.body()->GetURL()));
+
+  EXPECT_EQ(1, delegate.on_request_handled_counter());
 }
 
 // Tests that the destroying the loader cancels the request.
 TEST_F(NavigationURLLoaderTest, CancelOnDestruct) {
   // Fake a top-level request. Choose a URL which redirects so the request can
   // be paused before the response comes in.
   TestNavigationURLLoaderDelegate delegate;
   scoped_ptr<NavigationURLLoader> loader =
       MakeTestLoader(net::URLRequestTestJob::test_url_redirect_to_url_2(),
                      &delegate);
@@ skipping 40 matching lines @@
 
   // Wait for the request to redirect.
   delegate.WaitForRequestRedirected();
 
   // Cancel all requests.
   host_.CancelRequestsForContext(browser_context_->GetResourceContext());
 
   // Wait for the request to now be aborted.
   delegate.WaitForRequestFailed();
   EXPECT_EQ(net::ERR_ABORTED, delegate.net_error());
+  EXPECT_EQ(1, delegate.on_request_handled_counter());
 }
 
 // Tests that, if the request is blocked by the ResourceDispatcherHostDelegate,
 // the caller is informed appropriately.
 TEST_F(NavigationURLLoaderTest, RequestBlocked) {
   RequestBlockingResourceDispatcherHostDelegate rdh_delegate;
   host_.SetDelegate(&rdh_delegate);
 
   TestNavigationURLLoaderDelegate delegate;
   scoped_ptr<NavigationURLLoader> loader =
       MakeTestLoader(net::URLRequestTestJob::test_url_1(), &delegate);
 
   // Wait for the request to fail as expected.
   delegate.WaitForRequestFailed();
   EXPECT_EQ(net::ERR_ABORTED, delegate.net_error());
+  EXPECT_EQ(1, delegate.on_request_handled_counter());
 
   host_.SetDelegate(nullptr);
 }
 
 // Tests that ownership leaves the loader once the response is received.
 TEST_F(NavigationURLLoaderTest, LoaderDetached) {
   // Fake a top-level request to a URL whose body does not load immediately.
   TestNavigationURLLoaderDelegate delegate;
   scoped_ptr<NavigationURLLoader> loader =
       MakeTestLoader(net::URLRequestTestJob::test_url_2(), &delegate);
@@ skipping 27 matching lines @@
 
   // Release the body.
   delegate.ReleaseBody();
   base::RunLoop().RunUntilIdle();
 
   // Verify that URLRequestTestJob no longer has anything paused.
   EXPECT_FALSE(net::URLRequestTestJob::ProcessOnePendingMessage());
 }
 
 }  // namespace content