Move resource related IPCs to their own file in content.

chrome/common/resource_dispatcher_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 <string>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/common/resource_dispatcher.h"
-#include "chrome/common/resource_response.h"
+#include "content/common/resource_response.h"
+#include "content/common/resource_messages.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache_interfaces.h"
 
 using webkit_glue::ResourceLoaderBridge;
 using webkit_glue::ResourceResponseInfo;
 
 static const char test_page_url[] = "http://www.google.com/";
 static const char test_page_headers[] =
@@ skipping 66 matching lines @@
     message_queue_.push_back(IPC::Message(*msg));
     delete msg;
     return true;
   }
 
   // Emulates the browser process and processes the pending IPC messages,
   // returning the hardcoded file contents.
   void ProcessMessages() {
     while (!message_queue_.empty()) {
       int request_id;
-      ViewHostMsg_Resource_Request request;
-      ASSERT_TRUE(ViewHostMsg_RequestResource::Read(
+      ResourceHostMsg_Request request;
+      ASSERT_TRUE(ResourceHostMsg_RequestResource::Read(
           &message_queue_[0], &request_id, &request));
 
       // check values
       EXPECT_EQ(test_page_url, request.url.spec());
 
       // received response message
       ResourceResponseHead response;
       std::string raw_headers(test_page_headers);
       std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
       response.headers = new net::HttpResponseHeaders(raw_headers);
       response.mime_type = test_page_mime_type;
       response.charset = test_page_charset;
       dispatcher_->OnReceivedResponse(request_id, response);
 
       // received data message with the test contents
       base::SharedMemory shared_mem;
       EXPECT_TRUE(shared_mem.CreateAndMapAnonymous(test_page_contents_len));
       char* put_data_here = static_cast<char*>(shared_mem.memory());
       memcpy(put_data_here, test_page_contents, test_page_contents_len);
       base::SharedMemoryHandle dup_handle;
       EXPECT_TRUE(shared_mem.GiveToProcess(
           base::Process::Current().handle(), &dup_handle));
       dispatcher_->OnReceivedData(
           message_queue_[0], request_id, dup_handle, test_page_contents_len);
 
       message_queue_.erase(message_queue_.begin());
 
       // read the ack message.
       Tuple1<int> request_ack;
-      ASSERT_TRUE(ViewHostMsg_DataReceived_ACK::Read(
+      ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
           &message_queue_[0], &request_ack));
 
       ASSERT_EQ(request_ack.a, request_id);
 
       message_queue_.erase(message_queue_.begin());
     }
   }
 
  protected:
   // testing::Test
@@ skipping 79 matching lines @@
     return true;
   }
 
   void InitMessages() {
     set_defer_loading(true);
 
     ResourceResponseHead response_head;
     response_head.status.set_status(net::URLRequestStatus::SUCCESS);
 
     IPC::Message* response_message =
-        new ViewMsg_Resource_ReceivedResponse(0, 0, response_head);
+        new ResourceMsg_ReceivedResponse(0, 0, response_head);
 
     dispatcher_->OnMessageReceived(*response_message);
 
     delete response_message;
 
     // Duplicate the shared memory handle so both the test and the callee can
     // close their copy.
     base::SharedMemoryHandle duplicated_handle;
     EXPECT_TRUE(shared_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
                                               &duplicated_handle));
 
     response_message =
-        new ViewMsg_Resource_DataReceived(0, 0, duplicated_handle, 100);
+        new ResourceMsg_DataReceived(0, 0, duplicated_handle, 100);
 
     dispatcher_->OnMessageReceived(*response_message);
 
     delete response_message;
 
     set_defer_loading(false);
   }
 
   // ResourceLoaderBridge::Peer methods.
   virtual void OnUploadProgress(uint64 position, uint64 size) {
@@ skipping 58 matching lines @@
 
   ResourceLoaderBridge* bridge = CreateBridge();
 
   bridge->Start(this);
   InitMessages();
 
   // Dispatch deferred messages.
   message_loop.RunAllPending();
   delete bridge;
 }