Expose SPDY pushes in DevTools

chrome/browser/devtools/devtools_sanity_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
@@ skipping 36 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/switches.h"
 #include "extensions/common/value_builder.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
+#include "net/test/url_request/url_request_mock_http_job.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_filter.h"
+#include "net/url_request/url_request_http_job.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/gl/gl_switches.h"
+#include "url/gurl.h"
 
 using app_modal::AppModalDialog;
 using app_modal::JavaScriptAppModalDialog;
 using app_modal::NativeAppModalDialog;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::NavigationController;
 using content::RenderViewHost;
 using content::WebContents;
 using content::WorkerService;
 using content::WorkerServiceObserver;
 using extensions::Extension;
 
 namespace {
 
 const char kDebuggerTestPage[] = "files/devtools/debugger_test_page.html";
 const char kPauseWhenLoadingDevTools[] =
     "files/devtools/pause_when_loading_devtools.html";
 const char kPauseWhenScriptIsRunning[] =
     "files/devtools/pause_when_script_is_running.html";
 const char kPageWithContentScript[] =
     "files/devtools/page_with_content_script.html";
 const char kNavigateBackTestPage[] =
     "files/devtools/navigate_back.html";
 const char kWindowOpenTestPage[] = "files/devtools/window_open.html";
 const char kLatencyInfoTestPage[] = "files/devtools/latency_info.html";
 const char kChunkedTestPage[] = "chunked";
+const char kPushTestPage[] = "files/devtools/push_test_page.html";
+// The resource is not really pushed, but mock url request job pretends it is.
+const char kPushTestResource[] = "devtools/image.png";
+const char kPushUseNullEndTime[] = "pushUseNullEndTime";
 const char kSlowTestPage[] =
     "chunked?waitBeforeHeaders=100&waitBetweenChunks=100&chunksNumber=2";
 const char kSharedWorkerTestPage[] =
     "files/workers/workers_ui_shared_worker.html";
 const char kSharedWorkerTestWorker[] =
     "files/workers/workers_ui_shared_worker.js";
 const char kReloadSharedWorkerTestPage[] =
     "files/workers/debug_shared_worker_initialization.html";
 const char kReloadSharedWorkerTestWorker[] =
     "files/workers/debug_shared_worker_initialization.js";
@@ skipping 51 matching lines @@
                             const Extension* devtools_extension,
                             const char* panel_name) {
   // The full name is the concatenation of the extension URL (stripped of its
   // trailing '/') and the |panel_name| that was passed to panels.create().
   std::string prefix = base::TrimString(devtools_extension->url().spec(), "/",
                                         base::TRIM_TRAILING)
                            .as_string();
   SwitchToPanel(window, (prefix + panel_name).c_str());
 }
 
+class PushTimesMockURLRequestJob : public net::URLRequestMockHTTPJob {
+ public:
+  PushTimesMockURLRequestJob(net::URLRequest* request,
+                             net::NetworkDelegate* network_delegate,
+                             base::FilePath file_path)
+      : net::URLRequestMockHTTPJob(
+            request,
+            network_delegate,
+            file_path,
+            BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
+                base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)) {}
+
+  void Start() override {
+    load_timing_info_.socket_reused = true;
+    load_timing_info_.request_start_time = base::Time::Now();
+    load_timing_info_.request_start = base::TimeTicks::Now();
+    load_timing_info_.send_start = base::TimeTicks::Now();
+    load_timing_info_.send_end = base::TimeTicks::Now();
+    load_timing_info_.receive_headers_end = base::TimeTicks::Now();
+
+    net::URLRequestMockHTTPJob::Start();
+  }
+
+  void GetLoadTimingInfo(net::LoadTimingInfo* load_timing_info) const override {
+    load_timing_info_.push_start = load_timing_info_.request_start -
+                                   base::TimeDelta::FromMilliseconds(100);
+    if (load_timing_info_.push_end.is_null() &&
+        request()->url().query() != kPushUseNullEndTime) {
+      load_timing_info_.push_end = base::TimeTicks::Now();
+    }
+    *load_timing_info = load_timing_info_;
+  }
+
+ private:
+  mutable net::LoadTimingInfo load_timing_info_;
+  DISALLOW_COPY_AND_ASSIGN(PushTimesMockURLRequestJob);
+};
+
+class TestInterceptor : public net::URLRequestInterceptor {
+ public:
+  // Creates TestInterceptor and registers it with the URLRequestFilter,
+  // which takes ownership of it.
+  static void Register(const GURL& url, const base::FilePath& file_path) {
+    EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
+        url.scheme(), url.host(),
+        make_scoped_ptr(new TestInterceptor(url, file_path)));
+  }
+
+  // Unregisters previously created TestInterceptor, which should delete it.
+  static void Unregister(const GURL& url) {
+    EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(url.scheme(),
+                                                                url.host());
+  }
+
+  // net::URLRequestJobFactory::ProtocolHandler implementation:
+  net::URLRequestJob* MaybeInterceptRequest(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    if (request->url().path() != url_.path())
+      return nullptr;
+    return new PushTimesMockURLRequestJob(request, network_delegate,
+                                          file_path_);
+  }
+
+ private:
+  TestInterceptor(const GURL& url, const base::FilePath& file_path)
+      : url_(url), file_path_(file_path) {}
+
+  const GURL url_;
+  const base::FilePath file_path_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestInterceptor);
+};
+
 }  // namespace
 
 class DevToolsSanityTest : public InProcessBrowserTest {
  public:
   DevToolsSanityTest() : window_(NULL) {}
 
   void SetUpOnMainThread() override {
     host_resolver()->AddRule("*", "127.0.0.1");
   }
 
@@ skipping 757 matching lines @@
 // Tests raw headers text.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestNetworkSyncSize) {
   RunTest("testNetworkSyncSize", kChunkedTestPage);
 }
 
 // Tests raw headers text.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestNetworkRawHeadersText) {
   RunTest("testNetworkRawHeadersText", kChunkedTestPage);
 }
 
+// Tests raw headers text.

[dgozman, 2016/04/15 21:13:16]

Wrong comment. Just remove it.

+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestNetworkPushTime) {
+  OpenDevToolsWindow(kPushTestPage, false);
+  GURL push_url = spawned_test_server()->GetURL(kPushTestResource);
+  base::FilePath file_path =
+      spawned_test_server()->document_root().AppendASCII(kPushTestResource);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&TestInterceptor::Register, push_url, file_path));
+
+  DispatchOnTestSuite(window_, "testPushTimes", push_url.spec().c_str());
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&TestInterceptor::Unregister, push_url));
+
+  CloseDevToolsWindow();
+}
+
 // Tests that console messages are not duplicated on navigation back.
 #if defined(OS_WIN)
 // Flaking on windows swarm try runs: crbug.com/409285.
 #define MAYBE_TestConsoleOnNavigateBack DISABLED_TestConsoleOnNavigateBack
 #else
 #define MAYBE_TestConsoleOnNavigateBack TestConsoleOnNavigateBack
 #endif
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, MAYBE_TestConsoleOnNavigateBack) {
   RunTest("testConsoleOnNavigateBack", kNavigateBackTestPage);
 }
@@ skipping 286 matching lines @@
 
   SimulateTapAt(web_contents, gfx::Point(30, 60));
   DispatchInPageAndWait("waitForEvent", "gesturetap");
 
   DispatchAndWait("stopTimeline");
   RunTestMethod("checkInputEventsPresent", "MouseMove", "MouseDown",
                 "MouseWheel", "GestureTap");
 
   CloseDevToolsWindow();
 }