Rename ResourceMessageFilter to RenderMessageFilter, since that's what it act...

chrome/browser/nacl_host/nacl_process_host.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include "chrome/browser/nacl_host/nacl_process_host.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/metrics/nacl_histogram.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/renderer_host/resource_message_filter.h"
+#include "chrome/browser/renderer_host/render_message_filter.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/nacl_cmd_line.h"
 #include "chrome/common/nacl_messages.h"
 #include "chrome/common/render_messages.h"
 #include "ipc/ipc_switches.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #elif defined(OS_WIN)
@@ skipping 40 matching lines @@
     nacl::Close(sockets_for_renderer_[i]);
   }
   for (size_t i = 0; i < sockets_for_sel_ldr_.size(); i++) {
     nacl::Close(sockets_for_sel_ldr_[i]);
   }
 #endif
 
   // OnProcessLaunched didn't get called because the process couldn't launch.
   // Don't keep the renderer hanging.
   reply_msg_->set_reply_error();
-  resource_message_filter_->Send(reply_msg_);
+  render_message_filter_->Send(reply_msg_);
 }
 
-bool NaClProcessHost::Launch(ResourceMessageFilter* resource_message_filter,
+bool NaClProcessHost::Launch(RenderMessageFilter* render_message_filter,
                              int socket_count,
                              IPC::Message* reply_msg) {
 #ifdef DISABLE_NACL
   NOTIMPLEMENTED() << "Native Client disabled at build time";
   return false;
 #else
   // Place an arbitrary limit on the number of sockets to limit
   // exposure in case the renderer is compromised.  We can increase
   // this if necessary.
   if (socket_count > 8) {
@@ skipping 18 matching lines @@
     sockets_for_sel_ldr_.push_back(pair[1]);
     SetCloseOnExec(pair[0]);
     SetCloseOnExec(pair[1]);
   }
 
   // Launch the process
   if (!LaunchSelLdr()) {
     return false;
   }
   UmaNaclHistogramEnumeration(NACL_STARTED);
-  resource_message_filter_ = resource_message_filter;
+  render_message_filter_ = render_message_filter;
   reply_msg_ = reply_msg;
 
   return true;
 #endif  // DISABLE_NACL
 }
 
 bool NaClProcessHost::LaunchSelLdr() {
   if (!CreateChannel())
     return false;
 
@@ skipping 49 matching lines @@
 void NaClProcessHost::OnProcessLaunched() {
   std::vector<nacl::FileDescriptor> handles_for_renderer;
   base::ProcessHandle nacl_process_handle;
 
   for (size_t i = 0; i < sockets_for_renderer_.size(); i++) {
 #if defined(OS_WIN)
     // Copy the handle into the renderer process.
     HANDLE handle_in_renderer;
     DuplicateHandle(base::GetCurrentProcessHandle(),
                     reinterpret_cast<HANDLE>(sockets_for_renderer_[i]),
-                    resource_message_filter_->handle(),
+                    render_message_filter_->handle(),
                     &handle_in_renderer,
                     GENERIC_READ | GENERIC_WRITE,
                     FALSE,
                     DUPLICATE_CLOSE_SOURCE);
     handles_for_renderer.push_back(
         reinterpret_cast<nacl::FileDescriptor>(handle_in_renderer));
 #else
     // No need to dup the imc_handle - we don't pass it anywhere else so
     // it cannot be closed.
     nacl::FileDescriptor imc_handle;
     imc_handle.fd = sockets_for_renderer_[i];
     imc_handle.auto_close = true;
     handles_for_renderer.push_back(imc_handle);
 #endif
   }
 
 #if defined(OS_WIN)
   // Copy the process handle into the renderer process.
   DuplicateHandle(base::GetCurrentProcessHandle(),
                   handle(),
-                  resource_message_filter_->handle(),
+                  render_message_filter_->handle(),
                   &nacl_process_handle,
                   PROCESS_DUP_HANDLE,
                   FALSE,
                   0);
 #else
   // We use pid as process handle on Posix
   nacl_process_handle = handle();
 #endif
 
   // Get the pid of the NaCl process
   base::ProcessId nacl_process_id = base::GetProcId(handle());
 
   ViewHostMsg_LaunchNaCl::WriteReplyParams(
       reply_msg_, handles_for_renderer, nacl_process_handle, nacl_process_id);
-  resource_message_filter_->Send(reply_msg_);
-  resource_message_filter_ = NULL;
+  render_message_filter_->Send(reply_msg_);
+  render_message_filter_ = NULL;
   reply_msg_ = NULL;
   sockets_for_renderer_.clear();
 
   SendStartMessage();
 }
 
 void NaClProcessHost::SendStartMessage() {
   std::vector<nacl::FileDescriptor> handles_for_sel_ldr;
   for (size_t i = 0; i < sockets_for_sel_ldr_.size(); i++) {
 #if defined(OS_WIN)
@@ skipping 67 matching lines @@
   if (fnIsWow64Process != NULL) {
     BOOL bIsWow64 = FALSE;
     if (fnIsWow64Process(GetCurrentProcess(),&bIsWow64)) {
       if (bIsWow64) {
         running_on_wow64_ = true;
       }
     }
   }
 }
 #endif