Avoid duplicate functions/code in core/inspector.

third_party/WebKit/Source/core/inspector/InspectorNetworkAgent.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 189 matching lines @@
   }
 
   RefPtr<BlobDataHandle> blob_;
   String mime_type_;
   String text_encoding_name_;
   std::unique_ptr<GetResponseBodyCallback> callback_;
   std::unique_ptr<FileReaderLoader> loader_;
   RefPtr<SharedBuffer> raw_data_;
 };
 
-KURL UrlWithoutFragment(const KURL& url) {
-  KURL result = url;
-  result.RemoveFragmentIdentifier();
-  return result;
-}
-
 String MixedContentTypeForContextType(WebMixedContentContextType context_type) {
   switch (context_type) {
     case WebMixedContentContextType::kNotMixedContent:
       return protocol::Security::MixedContentTypeEnum::None;
     case WebMixedContentContextType::kBlockable:
       return protocol::Security::MixedContentTypeEnum::Blockable;
     case WebMixedContentContextType::kOptionallyBlockable:
     case WebMixedContentContextType::kShouldBeBlockable:
       return protocol::Security::MixedContentTypeEnum::OptionallyBlockable;
   }
@@ skipping 127 matching lines @@
       .setSendEnd(timing.CalculateMillisecondDelta(timing.SendEnd()))
       .setReceiveHeadersEnd(
           timing.CalculateMillisecondDelta(timing.ReceiveHeadersEnd()))
       .setPushStart(timing.PushStart())
       .setPushEnd(timing.PushEnd())
       .build();
 }
 
 static std::unique_ptr<protocol::Network::Request>
 BuildObjectForResourceRequest(const ResourceRequest& request) {
+  KURL nofragment_request_url(request.Url());
+  nofragment_request_url.RemoveFragmentIdentifier();
   std::unique_ptr<protocol::Network::Request> request_object =
       protocol::Network::Request::create()
-          .setUrl(UrlWithoutFragment(request.Url()).GetString())
+          .setUrl(nofragment_request_url.GetString())
           .setMethod(request.HttpMethod())
           .setHeaders(BuildObjectForHeaders(request.HttpHeaderFields()))
           .setInitialPriority(ResourcePriorityJSON(request.Priority()))
           .setReferrerPolicy(GetReferrerPolicy(request.GetReferrerPolicy()))
           .build();
   if (request.HttpBody() && !request.HttpBody()->IsEmpty()) {
     Vector<char> bytes;
     request.HttpBody()->Flatten(bytes);
     request_object->setPostData(
         String::FromUTF8WithLatin1Fallback(bytes.data(), bytes.size()));
@@ skipping 47 matching lines @@
   }
 
   // Use mime type from cached resource in case the one in response is empty.
   String mime_type = response.MimeType();
   if (mime_type.IsEmpty() && cached_resource)
     mime_type = cached_resource->GetResponse().MimeType();
 
   if (is_empty)
     *is_empty = !status && mime_type.IsEmpty() && !headers_map.size();
 
+  KURL nofragment_response_url(response.Url());
+  nofragment_response_url.RemoveFragmentIdentifier();
   std::unique_ptr<protocol::Network::Response> response_object =
       protocol::Network::Response::create()
-          .setUrl(UrlWithoutFragment(response.Url()).GetString())
+          .setUrl(nofragment_response_url.GetString())
           .setStatus(status)
           .setStatusText(status_text)
           .setHeaders(BuildObjectForHeaders(headers_map))
           .setMimeType(mime_type)
           .setConnectionReused(response.ConnectionReused())
           .setConnectionId(response.ConnectionID())
           .setEncodedDataLength(encoded_data_length)
           .setSecurityState(security_state)
           .build();
 
@@ skipping 206 matching lines @@
         MixedContentChecker::ContextTypeForInspector(loader->GetFrame(),
                                                      request)));
   }
 
   request_info->setReferrerPolicy(
       GetReferrerPolicy(request.GetReferrerPolicy()));
   if (initiator_info.is_link_preload)
     request_info->setIsLinkPreload(true);
 
   String resource_type = InspectorPageAgent::ResourceTypeJson(type);
-  String documentURL =
-      loader ? UrlWithoutFragment(loader->Url()).GetString()
-             : UrlWithoutFragment(execution_context->Url()).GetString();
+  KURL nofragment_document_url(loader ? loader->Url()
+                                      : execution_context->Url());
+  nofragment_document_url.RemoveFragmentIdentifier();
+  String documentURL = nofragment_document_url.GetString();
   Maybe<String> maybe_frame_id;
   if (!frame_id.IsEmpty())
     maybe_frame_id = frame_id;
   GetFrontend()->requestWillBeSent(
       request_id, loader_id, documentURL, std::move(request_info),
       MonotonicallyIncreasingTime(), CurrentTime(), std::move(initiator_object),
       BuildObjectForResourceResponse(redirect_response), resource_type,
       std::move(maybe_frame_id));
   if (pending_xhr_replay_data_ && !pending_xhr_replay_data_->Async())
     GetFrontend()->flush();
@@ skipping 265 matching lines @@
                                         const AtomicString& method,
                                         const KURL& url,
                                         bool async,
                                         PassRefPtr<EncodedFormData> form_data,
                                         const HTTPHeaderMap& headers,
                                         bool include_credentials) {
   DCHECK(xhr);
   DCHECK(!pending_request_);
   pending_request_ = client;
   pending_request_type_ = InspectorPageAgent::kXHRResource;
-  pending_xhr_replay_data_ = XHRReplayData::Create(
-      xhr->GetExecutionContext(), method, UrlWithoutFragment(url), async,
-      form_data.Get(), include_credentials);
+  KURL nofragment_url(url);
+  nofragment_url.RemoveFragmentIdentifier();
+  pending_xhr_replay_data_ =
+      XHRReplayData::Create(xhr->GetExecutionContext(), method, nofragment_url,
+                            async, form_data.Get(), include_credentials);
   for (const auto& header : headers)
     pending_xhr_replay_data_->AddHeader(header.key, header.value);
 }
 
 void InspectorNetworkAgent::DelayedRemoveReplayXHR(XMLHttpRequest* xhr) {
   if (!replay_xhrs_.Contains(xhr))
     return;
   replay_xhrs_to_be_deleted_.insert(xhr);
   replay_xhrs_.erase(xhr);
   remove_finished_replay_xhr_timer_.StartOneShot(0, BLINK_FROM_HERE);
@@ skipping 132 matching lines @@
   }
 
   while (document && !document->GetScriptableDocumentParser())
     document = document->LocalOwner() ? document->LocalOwner()->ownerDocument()
                                       : nullptr;
   if (document && document->GetScriptableDocumentParser()) {
     std::unique_ptr<protocol::Network::Initiator> initiator_object =
         protocol::Network::Initiator::create()
             .setType(protocol::Network::Initiator::TypeEnum::Parser)
             .build();
-    initiator_object->setUrl(UrlWithoutFragment(document->Url()).GetString());
+    KURL nofragment_document_url(document->Url());
+    nofragment_document_url.RemoveFragmentIdentifier();
+    initiator_object->setUrl(nofragment_document_url.GetString());
     if (TextPosition::BelowRangePosition() != initiator_info.position)
       initiator_object->setLineNumber(
           initiator_info.position.line_.ZeroBasedInt());
     else
       initiator_object->setLineNumber(
           document->GetScriptableDocumentParser()->LineNumber().ZeroBasedInt());
     return initiator_object;
   }
 
   return protocol::Network::Initiator::create()
       .setType(protocol::Network::Initiator::TypeEnum::Other)
       .build();
 }
 
 void InspectorNetworkAgent::DidCreateWebSocket(Document* document,
                                                unsigned long identifier,
                                                const KURL& request_url,
                                                const String&) {
   std::unique_ptr<v8_inspector::protocol::Runtime::API::StackTrace>
       current_stack_trace =
           SourceLocation::Capture(document)->BuildInspectorObject();
+  KURL nofragment_request_url(request_url);
+  nofragment_request_url.RemoveFragmentIdentifier();
   if (!current_stack_trace) {
-    GetFrontend()->webSocketCreated(
-        IdentifiersFactory::RequestId(identifier),
-        UrlWithoutFragment(request_url).GetString());
+    GetFrontend()->webSocketCreated(IdentifiersFactory::RequestId(identifier),
+                                    nofragment_request_url.GetString());
     return;
   }
 
   std::unique_ptr<protocol::Network::Initiator> initiator_object =
       protocol::Network::Initiator::create()
           .setType(protocol::Network::Initiator::TypeEnum::Script)
           .build();
   initiator_object->setStack(std::move(current_stack_trace));
   GetFrontend()->webSocketCreated(IdentifiersFactory::RequestId(identifier),
-                                  UrlWithoutFragment(request_url).GetString(),
+                                  nofragment_request_url.GetString(),
                                   std::move(initiator_object));
 }
 
 void InspectorNetworkAgent::WillSendWebSocketHandshakeRequest(
     Document*,
     unsigned long identifier,
     const WebSocketHandshakeRequest* request) {
   DCHECK(request);
   std::unique_ptr<protocol::Network::WebSocketRequest> request_object =
       protocol::Network::WebSocketRequest::create()
@@ skipping 438 matching lines @@
   DCHECK((IsMainThread() && inspected_frames_ && !worker_global_scope_) ||
          (!IsMainThread() && !inspected_frames_ && worker_global_scope_));
 }
 
 void InspectorNetworkAgent::ShouldForceCORSPreflight(bool* result) {
   if (state_->booleanProperty(NetworkAgentState::kCacheDisabled, false))
     *result = true;
 }
 
 }  // namespace blink