Move PROFILE_DESTROYED notification to ProfileDestroyer and observe it in ExtensionProcessManager.

chrome/browser/profiles/profile_destroyer.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 "chrome/browser/profiles/profile_destroyer.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 
 
 namespace {
 
 const int64 kTimerDelaySeconds = 1;
 
 }  // namespace
 
 std::vector<ProfileDestroyer*>* ProfileDestroyer::pending_destroyers_ = NULL;
 
 // static
 void ProfileDestroyer::DestroyProfileWhenAppropriate(Profile* const profile) {
   DCHECK(profile);
+  content::NotificationService::current()->Notify(

[Yoyo Zhou, 2012/07/25 18:13:00]

I wanted to put this in the ProfileDestroyer initializer, but that would be too
late for the DCHECK at 45 for normal profiles -- extension background pages
would still be hanging around.

+      chrome::NOTIFICATION_PROFILE_DESTROYED,
+      content::Source<Profile>(profile),
+      content::NotificationService::NoDetails());
+
   std::vector<content::RenderProcessHost*> hosts;
   // Testing profiles can simply be deleted directly. Some tests don't setup
   // RenderProcessHost correctly and don't necessary run on the UI thread
   // anyway, so we can't use the AllHostIterator.
   if (profile->AsTestingProfile() == NULL) {
     GetHostsForProfile(profile, &hosts);
     if (!profile->IsOffTheRecord() && profile->HasOffTheRecordProfile())
       GetHostsForProfile(profile->GetOffTheRecordProfile(), &hosts);
   }
   // This should never happen for non Off the record profile, this means that
   // there is a leak in a render process host that MUST BE FIXED!!!
   DCHECK(hosts.empty() || profile->IsOffTheRecord());

[Matt Perry, 2012/07/25 19:32:08]

you should change the DCHECK now that it works for OTR

   // Note that we still test for !profile->IsOffTheRecord here even though we
   // DCHECK'd above because we want to protect Release builds against this even
   // we need to identify if there are leaks when we run Debug builds.
   if (hosts.empty() || !profile->IsOffTheRecord()) {
     if (profile->IsOffTheRecord())
       profile->GetOriginalProfile()->DestroyOffTheRecordProfile();
     else
       delete profile;
   } else {
     // The instance will destroy itself once all render process hosts referring
@@ skipping 29 matching lines @@
     Profile* const profile,
     const std::vector<content::RenderProcessHost*>& hosts)
     : timer_(false, false),
       num_hosts_(0),
       profile_(profile) {
   if (pending_destroyers_ == NULL)
     pending_destroyers_ = new std::vector<ProfileDestroyer*>;
   pending_destroyers_->push_back(this);
   for (size_t i = 0; i < hosts.size(); ++i) {
     registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-        content::Source<content::RenderProcessHost>(hosts[i]));
+                   content::Source<content::RenderProcessHost>(hosts[i]));
     // For each of the notifications, we bump up our reference count.
     // It will go back to 0 and free us when all hosts are terminated.
     ++num_hosts_;
   }
   // If we are going to wait for render process hosts, we don't want to do it
   // for longer than kTimerDelaySeconds.
   if (num_hosts_) {
     timer_.Start(FROM_HERE,
                  base::TimeDelta::FromSeconds(kTimerDelaySeconds),
                  base::Bind(&ProfileDestroyer::DestroyProfile, this));
@@ skipping 20 matching lines @@
   if (pending_destroyers_->empty()) {
     delete pending_destroyers_;
     pending_destroyers_ = NULL;
   }
 }
 
 void ProfileDestroyer::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_TERMINATED);
+  registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,

[Yoyo Zhou, 2012/07/25 18:13:00]

It turns out the current implementation doesn't reach this point, but a previous
attempt did, and this appeared to be missing.

+                    source);
   DCHECK(num_hosts_ > 0);
   --num_hosts_;
   if (num_hosts_ == 0) {
     // Delay the destruction one step further in case other observers of this
     // notification need to look at the profile attached to the host.
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&ProfileDestroyer::DestroyProfile, this));
   }
 }
 
@@ skipping 22 matching lines @@
         content::RenderProcessHost::AllHostsIterator());
       !iter.IsAtEnd(); iter.Advance()) {
     content::RenderProcessHost* render_process_host = iter.GetCurrentValue();
     if (render_process_host && Profile::FromBrowserContext(
           render_process_host->GetBrowserContext()) == profile) {
       hosts->push_back(render_process_host);
     }
   }
   return !hosts->empty();
 }