Define parameter structs of resource messages out of resource_messages.h

content/child/resource_dispatcher_unittest.cc

 // 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.
 
 #include "content/child/resource_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
 #include "content/common/appcache_interfaces.h"
 #include "content/common/resource_messages.h"
+#include "content/common/resource_request.h"
+#include "content/common/resource_request_completion_status.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/child/fixed_received_data.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/child/resource_dispatcher_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ skipping 129 matching lines @@
       ADD_FAILURE() << "Missing resource request message";
       return -1;
     }
 
     ResourceHostMsg_RequestResource::Param params;
     if (ResourceHostMsg_RequestResource::ID != message_queue_[0].type() ||
         !ResourceHostMsg_RequestResource::Read(&message_queue_[0], &params)) {
       ADD_FAILURE() << "Expected ResourceHostMsg_RequestResource message";
       return -1;
     }
-    ResourceHostMsg_Request request = base::get<2>(params);
+    ResourceRequest request = base::get<2>(params);
     EXPECT_EQ(kTestPageUrl, request.url.spec());
     message_queue_.erase(message_queue_.begin());
     return base::get<1>(params);
   }
 
   void ConsumeFollowRedirect(int expected_request_id) {
     ASSERT_FALSE(message_queue_.empty());
     base::Tuple<int> args;
     ASSERT_EQ(ResourceHostMsg_FollowRedirect::ID, message_queue_[0].type());
     ASSERT_TRUE(ResourceHostMsg_FollowRedirect::Read(
@@ skipping 90 matching lines @@
         ResourceMsg_DataReceived(request_id, 0, data.length(), data.length())));
   }
 
   void NotifyDataDownloaded(int request_id, int decoded_length,
                             int encoded_length) {
     EXPECT_TRUE(dispatcher_->OnMessageReceived(ResourceMsg_DataDownloaded(
         request_id, decoded_length, encoded_length)));
   }
 
   void NotifyRequestComplete(int request_id, size_t total_size) {
-    ResourceMsg_RequestCompleteData request_complete_data;
+    ResourceRequestCompletionStatus request_complete_data;
     request_complete_data.error_code = net::OK;
     request_complete_data.was_ignored_by_handler = false;
     request_complete_data.exists_in_cache = false;
     request_complete_data.encoded_data_length = total_size;
     EXPECT_TRUE(dispatcher_->OnMessageReceived(
         ResourceMsg_RequestComplete(request_id, request_complete_data)));
   }
 
   RequestInfo* CreateRequestInfo(bool download_to_file) {
     RequestInfo* request_info = new RequestInfo();
@@ skipping 596 matching lines @@
   ResourceResponseHead response_head;
 
   PerformTest(response_head);
 
   EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
   EXPECT_EQ(base::TimeTicks(),
             response_info().load_timing.connect_timing.dns_start);
 }
 
 }  // namespace content