Move Origin::GetURL() out of resource request critical path

content/child/resource_dispatcher.h

 // 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #ifndef CONTENT_CHILD_RESOURCE_DISPATCHER_H_
 #define CONTENT_CHILD_RESOURCE_DISPATCHER_H_
 
 #include <stdint.h>
@@ skipping 11 matching lines @@
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "content/common/content_export.h"
 #include "content/common/url_loader.mojom.h"
 #include "content/public/common/resource_type.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "net/base/request_priority.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 
 namespace mojo {
 class AssociatedGroup;
 }  // namespace mojo
 
 namespace net {
 struct RedirectInfo;
 }
 
 namespace content {
 class RequestPeer;
 class ResourceDispatcherDelegate;
-class ResourceRequestBodyImpl;
 class ResourceSchedulingFilter;
 struct ResourceResponseInfo;
-struct RequestInfo;
 struct ResourceRequest;
 struct ResourceRequestCompletionStatus;
 struct ResourceResponseHead;
 class SharedMemoryReceivedDataFactory;
 struct SiteIsolationResponseMetaData;
 struct SyncLoadResponse;
 
 namespace mojom {
 class URLLoaderFactory;
 }  // namespace mojom
@@ skipping 34 matching lines @@
   //
   // |routing_id| is used to associated the bridge with a frame's network
   // context.
   //
   // You can pass an optional argument |loading_task_runner| to specify task
   // queue to execute loading tasks on.
   virtual int StartAsync(
       std::unique_ptr<ResourceRequest> request,
       int routing_id,
       scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner,
-      const GURL& frame_origin,
+      const url::Origin& frame_origin,
       std::unique_ptr<RequestPeer> peer,
       blink::WebURLRequest::LoadingIPCType ipc_type,
       mojom::URLLoaderFactory* url_loader_factory,
       mojo::AssociatedGroup* associated_group);
 
   // Removes a request from the |pending_requests_| list, returning true if the
   // request was found and removed.
   bool RemovePendingRequest(int request_id);
 
   // Cancels a request in the |pending_requests_| list.  The request will be
@@ skipping 39 matching lines @@
 
  private:
   friend class URLResponseBodyConsumer;
   friend class ResourceDispatcherTest;
 
   typedef std::deque<IPC::Message*> MessageQueue;
   struct PendingRequestInfo {
     PendingRequestInfo(std::unique_ptr<RequestPeer> peer,
                        ResourceType resource_type,
                        int origin_pid,
-                       const GURL& frame_origin,
+                       const url::Origin& frame_origin,
                        const GURL& request_url,
                        bool download_to_file);
 
     ~PendingRequestInfo();
 
     std::unique_ptr<RequestPeer> peer;
     ResourceType resource_type;
     // The PID of the original process which issued this request. This gets
     // non-zero only for a request proxied by another renderer, particularly
     // requests from plugins.
     int origin_pid;
     MessageQueue deferred_message_queue;
     bool is_deferred = false;
     // Original requested url.
     GURL url;
     // The security origin of the frame that initiates this request.
-    GURL frame_origin;
+    url::Origin frame_origin;
     // The url of the latest response even in case of redirection.
     GURL response_url;
     bool download_to_file;
     std::unique_ptr<IPC::Message> pending_redirect_message;
     base::TimeTicks request_start;
     base::TimeTicks response_start;
     base::TimeTicks completion_time;
     linked_ptr<base::SharedMemory> buffer;
     scoped_refptr<SharedMemoryReceivedDataFactory> received_data_factory;
     std::unique_ptr<SiteIsolationResponseMetaData> site_isolation_metadata;
@@ skipping 62 matching lines @@
   // handle in it that we should cleanup it up nicely. This method accepts any
   // message and determine whether the message is
   // ViewHostMsg_Resource_DataReceived and clean up the shared memory handle.
   static void ReleaseResourcesInDataMessage(const IPC::Message& message);
 
   // Iterate through a message queue and clean up the messages by calling
   // ReleaseResourcesInDataMessage and removing them from the queue. Intended
   // for use on deferred message queues that are no longer needed.
   static void ReleaseResourcesInMessageQueue(MessageQueue* queue);
 
-  std::unique_ptr<ResourceRequest> CreateRequest(
-      const RequestInfo& request_info,
-      ResourceRequestBodyImpl* request_body,
-      GURL* frame_origin);
-
   IPC::Sender* message_sender_;
 
   // All pending requests issued to the host
   PendingRequestMap pending_requests_;
 
   ResourceDispatcherDelegate* delegate_;
 
   // IO thread timestamp for ongoing IPC message.
   base::TimeTicks io_timestamp_;
 
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter_;
 
   base::WeakPtrFactory<ResourceDispatcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_RESOURCE_DISPATCHER_H_