content: convert child process notifications to observer usage

content/browser/browser_child_process_host_impl.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/browser/browser_child_process_host_impl.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "content/browser/histogram_message_filter.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/profiler_message_filter.h"
 #include "content/browser/tracing/trace_message_filter.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/plugin_messages.h"
 #include "content/public/browser/browser_child_process_host_delegate.h"
+#include "content/public/browser/browser_child_process_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/mach_broker_mac.h"
 #endif
 
 namespace content {
 namespace {
 
 static base::LazyInstance<BrowserChildProcessHostImpl::BrowserChildProcessList>
     g_child_process_list = LAZY_INSTANCE_INITIALIZER;
 
-// Helper functions since the child process related notifications happen on the
-// UI thread.
-void ChildNotificationHelper(int notification_type,
-                             const ChildProcessData& data) {
-  NotificationService::current()->Notify(
-      notification_type, NotificationService::AllSources(),
-      Details<const ChildProcessData>(&data));
+base::LazyInstance<ObserverList<BrowserChildProcessObserver> >
+    g_observers = LAZY_INSTANCE_INITIALIZER;
+
+void NotifyProcessHostConnected(const ChildProcessData& data) {
+  FOR_EACH_OBSERVER(BrowserChildProcessObserver, g_observers.Get(),
+                    BrowserChildProcessHostConnected(data));
+}
+
+void NotifyProcessHostDisconnected(const ChildProcessData& data) {
+  FOR_EACH_OBSERVER(BrowserChildProcessObserver, g_observers.Get(),
+                    BrowserChildProcessHostDisconnected(data));
+}
+
+void NotifyProcessCrashed(const ChildProcessData& data) {
+  FOR_EACH_OBSERVER(BrowserChildProcessObserver, g_observers.Get(),
+                    BrowserChildProcessCrashed(data));
 }
 
 }  // namespace
 
 BrowserChildProcessHost* BrowserChildProcessHost::Create(
     ProcessType type,
     BrowserChildProcessHostDelegate* delegate) {
   return new BrowserChildProcessHostImpl(type, delegate);
 }
 
 #if defined(OS_MACOSX)
 base::ProcessMetrics::PortProvider* BrowserChildProcessHost::GetPortProvider() {
   return MachBroker::GetInstance();
 }
 #endif
 
+// static
 BrowserChildProcessHostImpl::BrowserChildProcessList*
     BrowserChildProcessHostImpl::GetIterator() {
   return g_child_process_list.Pointer();
 }
 
+// static
+void BrowserChildProcessHostImpl::AddObserver(
+    BrowserChildProcessObserver* observer) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  g_observers.Get().AddObserver(observer);
+}
+
+// static
+void BrowserChildProcessHostImpl::RemoveObserver(
+    BrowserChildProcessObserver* observer) {
+  // TODO(phajdan.jr): Check thread after fixing http://crbug.com/167126.
+  g_observers.Get().RemoveObserver(observer);
+}
+
 BrowserChildProcessHostImpl::BrowserChildProcessHostImpl(
     ProcessType type,
     BrowserChildProcessHostDelegate* delegate)
     : data_(type),
       delegate_(delegate) {
   data_.id = ChildProcessHostImpl::GenerateChildProcessUniqueId();
 
   child_process_host_.reset(ChildProcessHost::Create(this));
   child_process_host_->AddFilter(new TraceMessageFilter);
   child_process_host_->AddFilter(new ProfilerMessageFilter(type));
@@ skipping 94 matching lines @@
   g_child_process_list.Get().remove(this);
   child_process_host_->ForceShutdown();
 }
 
 void BrowserChildProcessHostImpl::SetTerminateChildOnShutdown(
     bool terminate_on_shutdown) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   child_process_->SetTerminateChildOnShutdown(terminate_on_shutdown);
 }
 
-void BrowserChildProcessHostImpl::Notify(int type) {
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&ChildNotificationHelper, type, data_));
+void BrowserChildProcessHostImpl::NotifyProcessInstanceCreated(
+    const ChildProcessData& data) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  FOR_EACH_OBSERVER(BrowserChildProcessObserver, g_observers.Get(),
+                    BrowserChildProcessInstanceCreated(data));
 }
 
 base::TerminationStatus BrowserChildProcessHostImpl::GetTerminationStatus(
     int* exit_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!child_process_.get())  // If the delegate doesn't use Launch() helper.
     return base::GetTerminationStatus(data_.handle, exit_code);
   return child_process_->GetChildTerminationStatus(false /* known_dead */,
                                                    exit_code);
 }
 
 bool BrowserChildProcessHostImpl::OnMessageReceived(
     const IPC::Message& message) {
   return delegate_->OnMessageReceived(message);
 }
 
 void BrowserChildProcessHostImpl::OnChannelConnected(int32 peer_pid) {
-  Notify(NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&NotifyProcessHostConnected, data_));
   delegate_->OnChannelConnected(peer_pid);
 }
 
 void BrowserChildProcessHostImpl::OnChannelError() {
   delegate_->OnChannelError();
 }
 
 bool BrowserChildProcessHostImpl::CanShutdown() {
   return delegate_->CanShutdown();
 }
 
 void BrowserChildProcessHostImpl::OnChildDisconnected() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(data_.handle != base::kNullProcessHandle);
   int exit_code;
   base::TerminationStatus status = GetTerminationStatus(&exit_code);
   switch (status) {
     case base::TERMINATION_STATUS_PROCESS_CRASHED:
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION: {
       delegate_->OnProcessCrashed(exit_code);
-      // Report that this child process crashed.
-      Notify(NOTIFICATION_CHILD_PROCESS_CRASHED);
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                              base::Bind(&NotifyProcessCrashed, data_));
       UMA_HISTOGRAM_ENUMERATION("ChildProcess.Crashed",
                                 data_.type,
                                 PROCESS_TYPE_MAX);
       break;
     }
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED: {
       delegate_->OnProcessCrashed(exit_code);
       // Report that this child process was killed.
       UMA_HISTOGRAM_ENUMERATION("ChildProcess.Killed",
                                 data_.type,
                                 PROCESS_TYPE_MAX);
       break;
     }
     case base::TERMINATION_STATUS_STILL_RUNNING: {
       UMA_HISTOGRAM_ENUMERATION("ChildProcess.DisconnectedAlive",
                                 data_.type,
                                 PROCESS_TYPE_MAX);
     }
     default:
       break;
   }
   UMA_HISTOGRAM_ENUMERATION("ChildProcess.Disconnected",
                             data_.type,
                             PROCESS_TYPE_MAX);
-  // Notify in the main loop of the disconnection.
-  Notify(NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&NotifyProcessHostDisconnected, data_));
   delete delegate_;  // Will delete us
 }
 
 bool BrowserChildProcessHostImpl::Send(IPC::Message* message) {
   return child_process_host_->Send(message);
 }
 
 void BrowserChildProcessHostImpl::OnProcessLaunched() {
   if (!child_process_->GetHandle()) {
     delete delegate_;  // Will delete us
     return;
   }
   data_.handle = child_process_->GetHandle();
   delegate_->OnProcessLaunched();
 }
 
 }  // namespace content