content: convert child process notifications to observer usage

content/browser/media/webrtc_internals.cc

 // Copyright (c) 2013 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/media/webrtc_internals.h"
 
 #include "content/browser/media/webrtc_internals_ui_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 17 matching lines @@
       dict->Set("log", log);
   }
   return log;
 }
 
 }  // namespace
 
 WebRTCInternals::WebRTCInternals() {
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  NotificationService::AllBrowserContextsAndSources());
-  registrar_.Add(this, NOTIFICATION_CHILD_PROCESS_CRASHED,
-                 NotificationService::AllBrowserContextsAndSources());
+
+  BrowserChildProcessObserver::Add(this);
 }
 
 WebRTCInternals::~WebRTCInternals() {
+  BrowserChildProcessObserver::Remove(this);
 }
 
 WebRTCInternals* WebRTCInternals::GetInstance() {
   return Singleton<WebRTCInternals>::get();
 }
 
 void WebRTCInternals::AddPeerConnection(int render_process_id,
                                         ProcessId pid,
                                         int lid,
                                         const string& url,
@@ skipping 118 matching lines @@
 }
 
 void WebRTCInternals::SendUpdate(const string& command, Value* value) {
   DCHECK_GT(observers_.size(), (size_t)0);
 
   FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
                     observers_,
                     OnUpdate(command, value));
 }
 
+void WebRTCInternals::BrowserChildProcessCrashed(
+    const ChildProcessData& data) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  OnRendererExit(data.id);
+}
+
 void WebRTCInternals::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  int render_process_id = -1;
+  DCHECK_EQ(type, NOTIFICATION_RENDERER_PROCESS_TERMINATED);
+  OnRendererExit(Source<RenderProcessHost>(source)->GetID());
+}
 
-  switch (type) {
-    case NOTIFICATION_RENDERER_PROCESS_TERMINATED:
-      render_process_id = Source<RenderProcessHost>(source)->GetID();
-      break;
-    case NOTIFICATION_CHILD_PROCESS_CRASHED:
-      render_process_id = Details<ChildProcessData>(details).ptr()->id;
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-
+void WebRTCInternals::OnRendererExit(int render_process_id) {
   // Iterates from the end of the list to remove the PeerConnections created
   // by the exitting renderer.
   for (int i = peer_connection_data_.GetSize() - 1; i >= 0; --i) {
     DictionaryValue* record = NULL;
     peer_connection_data_.GetDictionary(i, &record);
 
     int this_rid = 0;
     record->GetInteger("rid", &this_rid);
 
     if (this_rid == render_process_id) {
       if (observers_.size() > 0) {
         int lid = 0, pid = 0;
         record->GetInteger("lid", &lid);
         record->GetInteger("pid", &pid);
 
         DictionaryValue update;
         update.SetInteger("lid", lid);
         update.SetInteger("pid", pid);
         SendUpdate("removePeerConnection", &update);
       }
       peer_connection_data_.Remove(i, NULL);
     }
   }
 }
 
 }  // namespace content