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

chrome/browser/gpu_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 "chrome/browser/gpu_process_host.h"
 
 #include "app/app_switches.h"
 #include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/string_piece.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/gpu_blacklist.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
+#include "chrome/browser/renderer_host/render_message_filter.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
-#include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_feature_flags.h"
 #include "chrome/common/gpu_info.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
 #include "grit/browser_resources.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
@@ skipping 106 matching lines @@
 void GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   if (message.routing_id() == MSG_ROUTING_CONTROL)
     OnControlMessageReceived(message);
   else
     RouteOnUIThread(message);
 }
 
 void GpuProcessHost::EstablishGpuChannel(int renderer_id,
-                                         ResourceMessageFilter* filter) {
+                                         RenderMessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   if (Send(new GpuMsg_EstablishChannel(renderer_id))) {
     sent_requests_.push(ChannelRequest(filter));
   } else {
     SendEstablishChannelReply(IPC::ChannelHandle(), GPUInfo(), filter);
   }
 }
 
 void GpuProcessHost::Synchronize(IPC::Message* reply,
-                                 ResourceMessageFilter* filter) {
+                                 RenderMessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   if (Send(new GpuMsg_Synchronize())) {
     queued_synchronization_replies_.push(SynchronizationRequest(reply, filter));
   } else {
     SendSynchronizationReply(reply, filter);
   }
 }
 
-GpuProcessHost::ChannelRequest::ChannelRequest(ResourceMessageFilter* filter)
+GpuProcessHost::ChannelRequest::ChannelRequest(RenderMessageFilter* filter)
     : filter(filter) {
 }
 
 GpuProcessHost::ChannelRequest::~ChannelRequest() {}
 
 GpuProcessHost::SynchronizationRequest::SynchronizationRequest(
     IPC::Message* reply,
-    ResourceMessageFilter* filter)
+    RenderMessageFilter* filter)
     : reply(reply),
       filter(filter) {
 }
 
 GpuProcessHost::SynchronizationRequest::~SynchronizationRequest() {}
 
 void GpuProcessHost::OnControlMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
@@ skipping 268 matching lines @@
       BrowserThread::UI, FROM_HERE,
       NewRunnableFunction(&GetCompositorHostWindowDispatcher,
           renderer_id, render_view_id, reply_message));
 }
 
 #endif
 
 void GpuProcessHost::SendEstablishChannelReply(
     const IPC::ChannelHandle& channel,
     const GPUInfo& gpu_info,
-    ResourceMessageFilter* filter) {
+    RenderMessageFilter* filter) {
   ViewMsg_GpuChannelEstablished* message =
       new ViewMsg_GpuChannelEstablished(channel, gpu_info);
   // If the renderer process is performing synchronous initialization,
   // it needs to handle this message before receiving the reply for
   // the synchronous ViewHostMsg_SynchronizeGpu message.
   message->set_unblock(true);
   filter->Send(message);
 }
 
 // Sends the response for synchronization request to the renderer.
 void GpuProcessHost::SendSynchronizationReply(
     IPC::Message* reply,
-    ResourceMessageFilter* filter) {
+    RenderMessageFilter* filter) {
   filter->Send(reply);
 }
 
 URLRequestContext* GpuProcessHost::GetRequestContext(
     uint32 request_id,
     const ViewHostMsg_Resource_Request& request_data) {
   return NULL;
 }
 
 bool GpuProcessHost::CanShutdown() {
@@ skipping 80 matching lines @@
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) ||
       blacklist->LoadGpuBlacklist(gpu_blacklist_json.as_string(), true)) {
     gpu_blacklist_.reset(blacklist);
     return true;
   }
   delete blacklist;
   return false;
 }