Show service worker navigation preload requests in DevTools Network tab.

content/browser/devtools/protocol/network_handler.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 "content/browser/devtools/protocol/network_handler.h"
 
 #include <stddef.h>
 
 #include "base/barrier_closure.h"
+#include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "content/browser/devtools/devtools_session.h"
+#include "content/browser/devtools/protocol/page.h"
+#include "content/browser/devtools/protocol/security.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/common/resource_request.h"
+#include "content/common/resource_request_completion_status.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/common/resource_devtools_info.h"
+#include "content/public/common/resource_response.h"
 #include "net/cookies/cookie_store.h"
+#include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace content {
 namespace protocol {
 namespace {
 
-using ProtocolCookieArray = protocol::Array<Network::Cookie>;
-using GetCookiesCallback = protocol::Network::Backend::GetCookiesCallback;
-using GetAllCookiesCallback = protocol::Network::Backend::GetAllCookiesCallback;
-using SetCookieCallback = protocol::Network::Backend::SetCookieCallback;
-using DeleteCookieCallback = protocol::Network::Backend::DeleteCookieCallback;
+using ProtocolCookieArray = Array<Network::Cookie>;
+using GetCookiesCallback = Network::Backend::GetCookiesCallback;
+using GetAllCookiesCallback = Network::Backend::GetAllCookiesCallback;
+using SetCookieCallback = Network::Backend::SetCookieCallback;
+using DeleteCookieCallback = Network::Backend::DeleteCookieCallback;
 
 net::URLRequestContext* GetRequestContextOnIO(
     ResourceContext* resource_context,
     net::URLRequestContextGetter* context_getter,
     const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::URLRequestContext* context =
       GetContentClient()->browser()->OverrideRequestContextForURL(
           url, resource_context);
   if (!context)
@@ skipping 182 matching lines @@
       expires,
       base::Time(),
       secure,
       http_only,
       same_site,
       are_experimental_cookie_features_enabled,
       net::COOKIE_PRIORITY_DEFAULT,
       base::Bind(&CookieSetOnIO, base::Passed(std::move(callback))));
 }
 
-std::vector<GURL> ComputeCookieURLs(
-    RenderFrameHostImpl* frame_host,
-    Maybe<protocol::Array<String>>& protocol_urls) {
+std::vector<GURL> ComputeCookieURLs(RenderFrameHostImpl* frame_host,
+                                    Maybe<Array<String>>& protocol_urls) {
   std::vector<GURL> urls;
 
   if (protocol_urls.isJust()) {
-    std::unique_ptr<protocol::Array<std::string>> actual_urls =
-        protocol_urls.takeJust();
+    std::unique_ptr<Array<std::string>> actual_urls = protocol_urls.takeJust();
 
     for (size_t i = 0; i < actual_urls->length(); i++)
       urls.push_back(GURL(actual_urls->get(i)));
   } else {
     std::queue<FrameTreeNode*> queue;
     queue.push(frame_host->frame_tree_node());
     while (!queue.empty()) {
       FrameTreeNode* node = queue.front();
       queue.pop();
 
       urls.push_back(node->current_url());
       for (size_t i = 0; i < node->child_count(); ++i)
         queue.push(node->child_at(i));
     }
   }
 
   return urls;
 }
 
+String resourcePriority(net::RequestPriority priority) {
+  switch (priority) {
+    case net::MINIMUM_PRIORITY:
+    case net::IDLE:
+      return Network::ResourcePriorityEnum::VeryLow;
+    case net::LOWEST:
+      return Network::ResourcePriorityEnum::Low;
+    case net::LOW:
+      return Network::ResourcePriorityEnum::Medium;
+    case net::MEDIUM:
+      return Network::ResourcePriorityEnum::High;
+    case net::HIGHEST:
+      return Network::ResourcePriorityEnum::VeryHigh;
+  }
+  NOTREACHED();
+  return Network::ResourcePriorityEnum::Medium;
+}
+
+String referrerPolicy(blink::WebReferrerPolicy referrer_policy) {
+  switch (referrer_policy) {
+    case blink::WebReferrerPolicyAlways:
+      return Network::Request::ReferrerPolicyEnum::UnsafeUrl;
+    case blink::WebReferrerPolicyDefault:
+      if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kReducedReferrerGranularity)) {
+        return Network::Request::ReferrerPolicyEnum::
+            NoReferrerWhenDowngradeOriginWhenCrossOrigin;
+      } else {
+        return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
+      }
+    case blink::WebReferrerPolicyNoReferrerWhenDowngrade:
+      return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
+    case blink::WebReferrerPolicyNever:
+      return Network::Request::ReferrerPolicyEnum::NoReferrer;
+    case blink::WebReferrerPolicyOrigin:
+      return Network::Request::ReferrerPolicyEnum::Origin;
+    case blink::WebReferrerPolicyOriginWhenCrossOrigin:
+      return Network::Request::ReferrerPolicyEnum::OriginWhenCrossOrigin;
+    case blink::WebReferrerPolicyNoReferrerWhenDowngradeOriginWhenCrossOrigin:
+      return Network::Request::ReferrerPolicyEnum::
+          NoReferrerWhenDowngradeOriginWhenCrossOrigin;
+  }
+  NOTREACHED();
+  return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
+}
+
+String securityState(const GURL& url, const net::CertStatus& cert_status) {
+  if (!url.SchemeIsCryptographic())
+    return Security::SecurityStateEnum::Neutral;
+  if (net::IsCertStatusError(cert_status) &&
+      !net::IsCertStatusMinorError(cert_status)) {
+    return Security::SecurityStateEnum::Insecure;
+  }
+  return Security::SecurityStateEnum::Secure;
+}
+
+double timeDelta(base::TimeTicks time,
+                 base::TimeTicks start,
+                 double invalid_value = -1) {
+  return time.is_null() ? invalid_value : (time - start).InMillisecondsF();
+}
+
+std::unique_ptr<Network::ResourceTiming> getTiming(
+    const net::LoadTimingInfo& load_timing) {
+  const base::TimeTicks kNullTicks;
+  return Network::ResourceTiming::Create()
+      .SetRequestTime((load_timing.request_start - kNullTicks).InSecondsF())
+      .SetProxyStart(
+          timeDelta(load_timing.proxy_resolve_start, load_timing.request_start))
+      .SetProxyEnd(
+          timeDelta(load_timing.proxy_resolve_end, load_timing.request_start))
+      .SetDnsStart(timeDelta(load_timing.connect_timing.dns_start,
+                             load_timing.request_start))
+      .SetDnsEnd(timeDelta(load_timing.connect_timing.dns_end,
+                           load_timing.request_start))
+      .SetConnectStart(timeDelta(load_timing.connect_timing.connect_start,
+                                 load_timing.request_start))
+      .SetConnectEnd(timeDelta(load_timing.connect_timing.connect_end,
+                               load_timing.request_start))
+      .SetSslStart(timeDelta(load_timing.connect_timing.ssl_start,
+                             load_timing.request_start))
+      .SetSslEnd(timeDelta(load_timing.connect_timing.ssl_end,
+                           load_timing.request_start))
+      .SetWorkerStart(-1)
+      .SetWorkerReady(-1)
+      .SetSendStart(
+          timeDelta(load_timing.send_start, load_timing.request_start))
+      .SetSendEnd(timeDelta(load_timing.send_end, load_timing.request_start))
+      .SetPushStart(
+          timeDelta(load_timing.push_start, load_timing.request_start, 0))
+      .SetPushEnd(timeDelta(load_timing.push_end, load_timing.request_start, 0))
+      .SetReceiveHeadersEnd(
+          timeDelta(load_timing.receive_headers_end, load_timing.request_start))
+      .Build();
+}
+
+std::unique_ptr<Object> getHeaders(const base::StringPairs& pairs) {
+  std::unique_ptr<DictionaryValue> headers_dict(DictionaryValue::create());
+  for (const auto& pair : pairs) {
+    headers_dict->setString(pair.first, pair.second);
+  }
+  return Object::fromValue(headers_dict.get(), nullptr);
+}
+
 }  // namespace
 
 NetworkHandler::NetworkHandler()
     : DevToolsDomainHandler(Network::Metainfo::domainName),
       host_(nullptr),
       enabled_(false) {
 }
 
 NetworkHandler::~NetworkHandler() {
 }
 
 // static
 NetworkHandler* NetworkHandler::FromSession(DevToolsSession* session) {
   return static_cast<NetworkHandler*>(
       session->GetHandlerByName(Network::Metainfo::domainName));
 }
 
 void NetworkHandler::Wire(UberDispatcher* dispatcher) {
+  frontend_.reset(new Network::Frontend(dispatcher->channel()));
   Network::Dispatcher::wire(dispatcher, this);
 }
 
 void NetworkHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
   host_ = host;
 }
 
 Response NetworkHandler::Enable(Maybe<int> max_total_size,
                                 Maybe<int> max_resource_size) {
   enabled_ = true;
@@ skipping 11 matching lines @@
     GetContentClient()->browser()->ClearCache(host_);
   return Response::OK();
 }
 
 Response NetworkHandler::ClearBrowserCookies() {
   if (host_)
     GetContentClient()->browser()->ClearCookies(host_);
   return Response::OK();
 }
 
-void NetworkHandler::GetCookies(
-    Maybe<protocol::Array<String>> protocol_urls,
-    std::unique_ptr<GetCookiesCallback> callback) {
+void NetworkHandler::GetCookies(Maybe<Array<String>> protocol_urls,
+                                std::unique_ptr<GetCookiesCallback> callback) {
   if (!host_) {
     callback->sendFailure(Response::InternalError());
     return;
   }
 
   std::vector<GURL> urls = ComputeCookieURLs(host_, protocol_urls);
   scoped_refptr<CookieRetriever> retriever =
       new CookieRetriever(std::move(callback));
 
   BrowserThread::PostTask(
@@ skipping 100 matching lines @@
   }
   user_agent_ = user_agent;
   return Response::FallThrough();
 }
 
 Response NetworkHandler::CanEmulateNetworkConditions(bool* result) {
   *result = false;
   return Response::OK();
 }
 
+void NetworkHandler::NavigationPreloadRequestSent(
+    const std::string& request_id,
+    const ResourceRequest& request) {
+  std::unique_ptr<DictionaryValue> headers_dict(DictionaryValue::create());

[pfeldman, 2017/01/26 18:10:20]

Check for enabled_ first, you might be not enabled yet.

[horo, 2017/01/26 22:53:19]

Done.

+  net::HttpRequestHeaders headers;
+  headers.AddHeadersFromString(request.headers);
+  for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();)
+    headers_dict->setString(it.name(), it.value());
+  frontend_->RequestWillBeSent(
+      request_id, "" /* frameId */, "" /* loaderId */, "" /* documentURL */,

[pfeldman, 2017/01/26 18:10:20]

What is this request_id? You should not clash with the renderer-initiated ones,
so you should prefix it.

You might also want to add some values for frameId and loaderId, those could be
supplied by your service worker. It is nice to know the origin of the request.

[horo, 2017/01/26 22:53:19]

Done.

request_id is created by MayBeReportToDevTools() in
service_worker_fetch_dispatcher.cc.

base::StringPrintf("preload-%d", fetch_event_id);

+      Network::Request::Create()
+          .SetUrl(request.url.spec())
+          .SetMethod(request.method)
+          .SetHeaders(Object::fromValue(headers_dict.get(), nullptr))
+          .SetInitialPriority(resourcePriority(request.priority))
+          .SetReferrerPolicy(referrerPolicy(request.referrer_policy))
+          .Build(),
+      base::TimeTicks::Now().ToInternalValue() /
+          static_cast<double>(base::Time::kMicrosecondsPerSecond),
+      base::Time::Now().ToDoubleT(),
+      Network::Initiator::Create()
+          .SetType(Network::Initiator::TypeEnum::Preload)
+          .Build(),
+      std::unique_ptr<Network::Response>(),
+      std::string(Page::ResourceTypeEnum::Other));
+}
+
+void NetworkHandler::NavigationPreloadResponseReceived(
+    const std::string& request_id,
+    const GURL& url,
+    const ResourceResponseHead& head) {
+  std::unique_ptr<DictionaryValue> headers_dict(DictionaryValue::create());

[pfeldman, 2017/01/26 18:10:20]

if (!enabled_)
  return;

[horo, 2017/01/26 22:53:19]

Done.

+  size_t iterator = 0;
+  std::string name;
+  std::string value;
+  while (head.headers->EnumerateHeaderLines(&iterator, &name, &value))
+    headers_dict->setString(name, value);
+  std::unique_ptr<Network::Response> response(
+      Network::Response::Create()
+          .SetUrl(url.spec())
+          .SetStatus(head.headers->response_code())
+          .SetStatusText(head.headers->GetStatusText())
+          .SetHeaders(Object::fromValue(headers_dict.get(), nullptr))
+          .SetMimeType(head.mime_type)
+          .SetConnectionReused(head.load_timing.socket_reused)
+          .SetConnectionId(head.load_timing.socket_log_id)
+          .SetSecurityState(securityState(url, head.cert_status))
+          .SetEncodedDataLength(head.encoded_data_length)
+          .SetTiming(getTiming(head.load_timing))
+          .SetFromDiskCache(!head.load_timing.request_start_time.is_null() &&
+                            head.response_time <
+                                head.load_timing.request_start_time)
+          .Build());
+  if (head.devtools_info) {

[pfeldman, 2017/01/26 18:10:20]

I don't see where you are setting report_raw_headers = true to the request so
that you could actually receive this info. It should be set conditionally to the
agent being there and being enabled.

[horo, 2017/01/26 22:53:19]

The |report_raw_headers| flag is copied from the original navigation request in
ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload().

+    response->SetStatus(head.devtools_info->http_status_code);
+    response->SetStatusText(head.devtools_info->http_status_text);
+    response->SetRequestHeaders(
+        getHeaders(head.devtools_info->request_headers));
+    response->SetHeaders(getHeaders(head.devtools_info->response_headers));
+    response->SetHeadersText(head.devtools_info->response_headers_text);
+  }
+  std::string protocol = head.alpn_negotiated_protocol;
+  if (protocol.empty() || protocol == "unknown") {
+    if (head.was_fetched_via_spdy) {

[pfeldman, 2017/01/26 18:10:20]

nit: You extracted the rest converters, you should extract this as well.

[horo, 2017/01/26 22:53:19]

Done.

+      protocol = "spdy";
+    } else if (url.SchemeIsHTTPOrHTTPS()) {
+      protocol = "http";
+      if (head.headers->GetHttpVersion() == net::HttpVersion(0, 9))
+        protocol = "http/0.9";
+      else if (head.headers->GetHttpVersion() == net::HttpVersion(1, 0))
+        protocol = "http/1.0";
+      else if (head.headers->GetHttpVersion() == net::HttpVersion(1, 1))
+        protocol = "http/1.1";
+    } else {
+      protocol = url.scheme();
+    }
+  }
+  response->SetProtocol(protocol);
+  response->SetRemoteIPAddress(head.socket_address.HostForURL());
+  response->SetRemotePort(head.socket_address.port());
+  frontend_->ResponseReceived(
+      request_id, "" /* frameId */, "" /* loaderId */,
+      base::TimeTicks::Now().ToInternalValue() /
+          static_cast<double>(base::Time::kMicrosecondsPerSecond),
+      Page::ResourceTypeEnum::Other, std::move(response));
+}
+
+void NetworkHandler::NavigationPreloadCompleted(
+    const std::string& request_id,
+    const ResourceRequestCompletionStatus& completion_status) {
+  if (completion_status.error_code != net::OK) {
+    frontend_->LoadingFailed(
+        request_id, base::TimeTicks::Now().ToInternalValue() /
+                        static_cast<double>(base::Time::kMicrosecondsPerSecond),
+        Page::ResourceTypeEnum::Other, "Navigation Preload Error",
+        completion_status.error_code == net::Error::ERR_ABORTED);
+  }
+  frontend_->LoadingFinished(
+      request_id, base::TimeTicks::Now().ToInternalValue() /
+                      static_cast<double>(base::Time::kMicrosecondsPerSecond),
+      completion_status.encoded_data_length);
+}
+
 std::string NetworkHandler::UserAgentOverride() const {
   return enabled_ ? user_agent_ : std::string();
 }
 
 }  // namespace protocol
 }  // namespace content