Move resource related IPCs to their own file in content.

content/browser/renderer_host/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
-#include "chrome/common/resource_response.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "content/browser/renderer_host/resource_handler.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
+#include "content/common/resource_messages.h"
+#include "content/common/resource_response.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_test_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache_interfaces.h"
 
 // TODO(eroman): Write unit tests for SafeBrowsing that exercise
 //               SafeBrowsingResourceHandler.
 
 namespace {
 
 // Returns the resource response header structure for this request.
 void GetResponseHead(const std::vector<IPC::Message>& messages,
                      ResourceResponseHead* response_head) {
   ASSERT_GE(messages.size(), 2U);
 
   // The first messages should be received response.
-  ASSERT_EQ(ViewMsg_Resource_ReceivedResponse::ID, messages[0].type());
+  ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
   void* iter = NULL;
   int request_id;
   ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, response_head));
 }
 
 }  // namespace
 
 static int RequestIDForMessage(const IPC::Message& msg) {
   int request_id = -1;
   switch (msg.type()) {
-    case ViewMsg_Resource_UploadProgress::ID:
-    case ViewMsg_Resource_ReceivedResponse::ID:
-    case ViewMsg_Resource_ReceivedRedirect::ID:
-    case ViewMsg_Resource_DataReceived::ID:
-    case ViewMsg_Resource_RequestComplete::ID:
+    case ResourceMsg_UploadProgress::ID:
+    case ResourceMsg_ReceivedResponse::ID:
+    case ResourceMsg_ReceivedRedirect::ID:
+    case ResourceMsg_DataReceived::ID:
+    case ResourceMsg_RequestComplete::ID:
       request_id = IPC::MessageIterator(msg).NextInt();
       break;
   }
   return request_id;
 }
 
-static ViewHostMsg_Resource_Request CreateResourceRequest(
+static ResourceHostMsg_Request CreateResourceRequest(
     const char* method,
     ResourceType::Type type,
     const GURL& url) {
-  ViewHostMsg_Resource_Request request;
+  ResourceHostMsg_Request request;
   request.method = std::string(method);
   request.url = url;
   request.first_party_for_cookies = url;  // bypass third-party cookie blocking
   request.load_flags = 0;
   request.origin_pid = 0;
   request.resource_type = type;
   request.request_context = 0;
   request.appcache_host_id = appcache::kNoHostId;
   request.download_to_file = false;
   request.host_renderer_id = -1;
@@ skipping 199 matching lines @@
                                                  int request_id,
                                                  const GURL& url) {
   MakeTestRequest(filter_.get(), render_view_id, request_id, url);
 }
 
 void ResourceDispatcherHostTest::MakeTestRequest(
     ResourceMessageFilter* filter,
     int render_view_id,
     int request_id,
     const GURL& url) {
-  ViewHostMsg_Resource_Request request =
+  ResourceHostMsg_Request request =
       CreateResourceRequest("GET", resource_type_, url);
-  ViewHostMsg_RequestResource msg(render_view_id, request_id, request);
+  ResourceHostMsg_RequestResource msg(render_view_id, request_id, request);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter, &msg_was_ok);
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::MakeCancelRequest(int request_id) {
   host_.CancelRequest(filter_->child_id(), request_id, false);
 }
 
 void CheckSuccessfulRequest(const std::vector<IPC::Message>& messages,
                             const std::string& reference_data) {
   // A successful request will have received 4 messages:
   //     ReceivedResponse    (indicates headers received)
   //     DataReceived        (data)
   //    XXX DataReceived        (0 bytes remaining from a read)
   //     RequestComplete     (request is done)
   //
   // This function verifies that we received 4 messages and that they
   // are appropriate.
   ASSERT_EQ(3U, messages.size());
 
   // The first messages should be received response
-  ASSERT_EQ(ViewMsg_Resource_ReceivedResponse::ID, messages[0].type());
+  ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
   // followed by the data, currently we only do the data in one chunk, but
   // should probably test multiple chunks later
-  ASSERT_EQ(ViewMsg_Resource_DataReceived::ID, messages[1].type());
+  ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[1].type());
 
   void* iter = NULL;
   int request_id;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &request_id));
   base::SharedMemoryHandle shm_handle;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_handle));
   uint32 data_len;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &data_len));
 
   ASSERT_EQ(reference_data.size(), data_len);
   base::SharedMemory shared_mem(shm_handle, true);  // read only
   shared_mem.Map(data_len);
   const char* data = static_cast<char*>(shared_mem.memory());
   ASSERT_EQ(0, memcmp(reference_data.c_str(), data, data_len));
 
   // followed by a 0-byte read
-  //ASSERT_EQ(ViewMsg_Resource_DataReceived::ID, messages[2].type());
+  //ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2].type());
 
   // the last message should be all data received
-  ASSERT_EQ(ViewMsg_Resource_RequestComplete::ID, messages[2].type());
+  ASSERT_EQ(ResourceMsg_RequestComplete::ID, messages[2].type());
 }
 
 // Tests whether many messages get dispatched properly.
 TEST_F(ResourceDispatcherHostTest, TestMany) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
 
@@ skipping 34 matching lines @@
   accum_.GetClassifiedMessages(&msgs);
 
   // there are three requests, so we should have gotten them classified as such
   ASSERT_EQ(3U, msgs.size());
 
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1());
   CheckSuccessfulRequest(msgs[2], net::URLRequestTestJob::test_data_3());
 
   // Check that request 2 got canceled.
   ASSERT_EQ(2U, msgs[1].size());
-  ASSERT_EQ(ViewMsg_Resource_ReceivedResponse::ID, msgs[1][0].type());
-  ASSERT_EQ(ViewMsg_Resource_RequestComplete::ID, msgs[1][1].type());
+  ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[1][0].type());
+  ASSERT_EQ(ResourceMsg_RequestComplete::ID, msgs[1][1].type());
 
   int request_id;
   net::URLRequestStatus status;
 
   void* iter = NULL;
   ASSERT_TRUE(IPC::ReadParam(&msgs[1][1], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&msgs[1][1], &iter, &status));
 
   EXPECT_EQ(net::URLRequestStatus::CANCELED, status.status());
 }
@@ skipping 18 matching lines @@
   }
   bool has_canceled_;
   int received_after_canceled_;
 };
 
 // Tests CancelRequestsForProcess
 TEST_F(ResourceDispatcherHostTest, TestProcessCancel) {
   scoped_refptr<TestFilter> test_filter = new TestFilter();
 
   // request 1 goes to the test delegate
-  ViewHostMsg_Resource_Request request = CreateResourceRequest(
+  ResourceHostMsg_Request request = CreateResourceRequest(
       "GET", ResourceType::SUB_RESOURCE, net::URLRequestTestJob::test_url_1());
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   MakeTestRequest(test_filter.get(), 0, 1,
                   net::URLRequestTestJob::test_url_1());
 
   // request 2 goes to us
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
 
@@ skipping 308 matching lines @@
   // Check that the first kMaxRequests succeeded.
   for (size_t i = 0; i < kMaxRequests; ++i)
     CheckSuccessfulRequest(msgs[i], net::URLRequestTestJob::test_data_2());
 
   // Check that the subsequent two requests (kMaxRequests + 1) and
   // (kMaxRequests + 2) were failed, since the per-process bound was reached.
   for (int i = 0; i < 2; ++i) {
     // Should have sent a single RequestComplete message.
     int index = kMaxRequests + i;
     EXPECT_EQ(1U, msgs[index].size());
-    EXPECT_EQ(ViewMsg_Resource_RequestComplete::ID, msgs[index][0].type());
+    EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[index][0].type());
 
     // The RequestComplete message should have had status
     // (CANCELLED, ERR_INSUFFICIENT_RESOURCES).
     int request_id;
     net::URLRequestStatus status;
 
     void* iter = NULL;
     EXPECT_TRUE(IPC::ReadParam(&msgs[index][0], &iter, &request_id));
     EXPECT_TRUE(IPC::ReadParam(&msgs[index][0], &iter, &status));
 
@@ skipping 143 matching lines @@
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We should have gotten one RequestComplete message.
   ASSERT_EQ(1U, msgs[0].size());
-  EXPECT_EQ(ViewMsg_Resource_RequestComplete::ID, msgs[0][0].type());
+  EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
   // The RequestComplete message should have had status
   // (CANCELED, ERR_FILE_NOT_FOUND).
   int request_id;
   net::URLRequestStatus status;
 
   void* iter = NULL;
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &status));
 
@@ skipping 58 matching lines @@
     return new ResourceDispatcherHostRequestInfo(
         resource_handler_.get(), ChildProcessInfo::RENDER_PROCESS, 0, 0, 0,
         ResourceType::STYLESHEET, 0U, false, false, false, -1, -1);
   }
 
   scoped_ptr<GURL> url_;
   ResourceType::Type resource_type_;
   scoped_ptr<DummyResourceHandler> resource_handler_;
   scoped_ptr<ResourceDispatcherHostRequestInfo> request_info_;
 };