Define parameter structs of resource messages out of resource_messages.h

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 10 matching lines @@
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "content/common/content_export.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 "url/gurl.h"
 
-struct ResourceHostMsg_Request;
-struct ResourceMsg_RequestCompleteData;
-
 namespace net {
 struct RedirectInfo;
 }
 
 namespace content {
 class RequestPeer;
 class ResourceDispatcherDelegate;
 class ResourceRequestBody;
 class ResourceSchedulingFilter;
 struct ResourceResponseInfo;
 struct RequestInfo;
+struct ResourceRequest;
+struct ResourceRequestCompletionStatus;
 struct ResourceResponseHead;
 class SharedMemoryReceivedDataFactory;
 struct SiteIsolationResponseMetaData;
 struct SyncLoadResponse;
 
 // This class serves as a communication interface to the ResourceDispatcherHost
 // in the browser process. It can be used from any child process.
 // Virtual methods are for tests.
 class CONTENT_EXPORT ResourceDispatcher : public IPC::Listener {
  public:
@@ skipping 125 matching lines @@
   void OnReceivedInlinedDataChunk(int request_id,
                                   const std::vector<char>& data,
                                   int encoded_data_length);
   void OnReceivedData(int request_id,
                       int data_offset,
                       int data_length,
                       int encoded_data_length);
   void OnDownloadedData(int request_id, int data_len, int encoded_data_length);
   void OnRequestComplete(
       int request_id,
-      const ResourceMsg_RequestCompleteData& request_complete_data);
+      const ResourceRequestCompletionStatus& request_complete_data);
 
   // Dispatch the message to one of the message response handlers.
   void DispatchMessage(const IPC::Message& message);
 
   // Dispatch any deferred messages for the given request, provided it is not
   // again in the deferred state. This method may mutate |pending_requests_|.
   void FlushDeferredMessages(int request_id);
 
   void ToResourceResponseInfo(const PendingRequestInfo& request_info,
                               const ResourceResponseHead& browser_info,
@@ skipping 15 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<ResourceHostMsg_Request> CreateRequest(
+  std::unique_ptr<ResourceRequest> CreateRequest(
       const RequestInfo& request_info,
       ResourceRequestBody* 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_