Decouple IPC::MessageFilter from IPC::Channel

content/child/child_thread.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/child_thread.h"
 
 #include <signal.h>
 
 #include <string>
 
@@ skipping 93 matching lines @@
   // A non joinable thread has been created. The thread will either terminate
   // the process or will be terminated by the process. Therefore, keep the
   // delegate object alive for the lifetime of the process.
   WaitAndExitDelegate* leaking_delegate = delegate.release();
   ANNOTATE_LEAKING_OBJECT_PTR(leaking_delegate);
   ignore_result(leaking_delegate);
   return true;
 }
 #endif
 
-class SuicideOnChannelErrorFilter : public IPC::MessageFilter {
+class SuicideOnSenderErrorFilter : public IPC::MessageFilter {
  public:
   // IPC::MessageFilter
-  virtual void OnChannelError() OVERRIDE {
+  virtual void OnSenderError() OVERRIDE {
     // For renderer/worker processes:
     // On POSIX, at least, one can install an unload handler which loops
     // forever and leave behind a renderer process which eats 100% CPU forever.
     //
     // This is because the terminate signals (ViewMsg_ShouldClose and the error
-    // from the IPC channel) are routed to the main message loop but never
+    // from the IPC sender) are routed to the main message loop but never
     // processed (because that message loop is stuck in V8).
     //
     // One could make the browser SIGKILL the renderers, but that leaves open a
     // large window where a browser failure (or a user, manually terminating
     // the browser because "it's stuck") will leave behind a process eating all
     // the CPU.
     //
-    // So, we install a filter on the channel so that we can process this event
+    // So, we install a filter on the sender so that we can process this event
     // here and kill the process.
     // TODO(earthdok): Re-enable on CrOS http://crbug.com/360622
 #if (defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || \
     defined(THREAD_SANITIZER)) && !defined(OS_CHROMEOS)
     // Some sanitizer tools rely on exit handlers (e.g. to run leak detection,
     // or dump code coverage data to disk). Instead of exiting the process
     // immediately, we give it 60 seconds to run exit handlers.
     CHECK(CreateWaitAndExitThread(base::TimeDelta::FromSeconds(60)));
 #if defined(LEAK_SANITIZER)
     // Invoke LeakSanitizer early to avoid detecting shutdown-only leaks. If
     // leaks are found, the process will exit here.
     __lsan_do_leak_check();
 #endif
 #else
     _exit(0);
 #endif
   }
 
  protected:
-  virtual ~SuicideOnChannelErrorFilter() {}
+  virtual ~SuicideOnSenderErrorFilter() {}
 };
 
 #endif  // OS(POSIX)
 
 #if defined(OS_ANDROID)
 ChildThread* g_child_thread = NULL;
 
 // A lock protects g_child_thread.
 base::LazyInstance<base::Lock> g_lazy_child_thread_lock =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 117 matching lines @@
     channel_->AddFilter(power_monitor_source->GetMessageFilter());
 
     power_monitor_.reset(new base::PowerMonitor(
         power_monitor_source.PassAs<base::PowerMonitorSource>()));
   }
 
 #if defined(OS_POSIX)
   // Check that --process-type is specified so we don't do this in unit tests
   // and single-process mode.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kProcessType))
-    channel_->AddFilter(new SuicideOnChannelErrorFilter());
+    channel_->AddFilter(new SuicideOnSenderErrorFilter());
 #endif
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ChildThread::EnsureConnected,
                  channel_connected_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kConnectionTimeoutS));
 
 #if defined(OS_ANDROID)
   {
@@ skipping 261 matching lines @@
   base::MessageLoop::current()->SetTimerSlack(timer_slack);
 
 #ifdef OS_WIN
   // Windows Vista+ has a fancy process backgrounding mode that can only be set
   // from within the process.
   base::Process::Current().SetProcessBackgrounded(background);
 #endif  // OS_WIN
 }
 
 }  // namespace content