Support DevTools for off-main-thread-fetch

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/base64.h"
@@ skipping 661 matching lines @@
     const ResourceRequest& request) {
   if (!enabled_)
     return;
   const std::string version_id(base::IntToString(worker_version_id));
   std::unique_ptr<DictionaryValue> headers_dict(DictionaryValue::create());
   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, version_id /* frameId */, version_id /* loaderId */,
-      "" /* documentURL */,
+      request_id, "" /* loader_id */, request.url.spec(),
       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(),
@@ skipping 49 matching lines @@
     }
     if (head.devtools_info->response_headers.size())
       response->SetHeaders(getHeaders(head.devtools_info->response_headers));
     if (!head.devtools_info->response_headers_text.empty())
       response->SetHeadersText(head.devtools_info->response_headers_text);
   }
   response->SetProtocol(getProtocol(url, head));
   response->SetRemoteIPAddress(head.socket_address.HostForURL());
   response->SetRemotePort(head.socket_address.port());
   frontend_->ResponseReceived(
-      request_id, version_id /* frameId */, version_id /* loaderId */,
+      request_id, "" /* loader_id */,
       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 (!enabled_)
     return;
@@ skipping 25 matching lines @@
                            base::IntToString(++next_id);
   std::string error_string = net::ErrorToString(error_code);
   bool cancelled = error_code == net::Error::ERR_ABORTED;
 
   std::unique_ptr<DictionaryValue> headers_dict(DictionaryValue::create());
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(begin_params.headers);
   for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();)
     headers_dict->setString(it.name(), it.value());
   frontend_->RequestWillBeSent(
-      request_id, request_id /* frameId */, request_id /* loaderId */,
-      common_params.url.spec(),
+      request_id, "" /* loader_id */, common_params.url.spec(),
       Network::Request::Create()
           .SetUrl(common_params.url.spec())
           .SetMethod(common_params.method)
           .SetHeaders(Object::fromValue(headers_dict.get(), nullptr))
           // Note: the priority value is copied from
           // ResourceDispatcherHostImpl::BeginNavigationRequest but there isn't
           // a good way of sharing this.
           .SetInitialPriority(resourcePriority(net::HIGHEST))
           .SetReferrerPolicy(referrerPolicy(common_params.referrer.policy))
           .Build(),
@@ skipping 125 matching lines @@
           .SetReferrerPolicy(referrerPolicy(request->referrer_policy()))
           .Build();
   std::string post_data;
   if (GetPostData(request, &post_data))
     request_object->SetPostData(std::move(post_data));
   return request_object;
 }
 
 }  // namespace protocol
 }  // namespace content