Introduce RenderProcessHostObserver, use it in its first client.

content/browser/site_instance_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/site_instance_impl.h"
 
 #include "base/command_line.h"
 #include "content/browser/browsing_instance.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/storage_partition_impl.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/browser/render_process_host_factory.h"
 #include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 
 namespace content {
 
 static bool IsURLSameAsAnySiteInstance(const GURL& url) {
   if (!url.is_valid())
@@ skipping 14 matching lines @@
     SiteInstanceImpl::g_render_process_host_factory_ = NULL;
 int32 SiteInstanceImpl::next_site_instance_id_ = 1;
 
 SiteInstanceImpl::SiteInstanceImpl(BrowsingInstance* browsing_instance)
     : id_(next_site_instance_id_++),
       active_view_count_(0),
       browsing_instance_(browsing_instance),
       process_(NULL),
       has_site_(false) {
   DCHECK(browsing_instance);
-
-  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-                 NotificationService::AllBrowserContextsAndSources());
 }
 
 SiteInstanceImpl::~SiteInstanceImpl() {
   GetContentClient()->browser()->SiteInstanceDeleting(this);
 
+  if (process_)
+    process_->RemoveObserver(this);
+
   // Now that no one is referencing us, we can safely remove ourselves from
   // the BrowsingInstance.  Any future visits to a page from this site
   // (within the same BrowsingInstance) can safely create a new SiteInstance.
   if (has_site_)
     browsing_instance_->UnregisterSiteInstance(
         static_cast<SiteInstance*>(this));
 }
 
 int32 SiteInstanceImpl::GetId() {
   return id_;
@@ skipping 55 matching lines @@
                 BrowserContext::GetStoragePartition(browser_context, this));
         bool supports_browser_plugin = GetContentClient()->browser()->
             SupportsBrowserPlugin(browser_context, site_);
         process_ = new RenderProcessHostImpl(browser_context,
                                              partition,
                                              supports_browser_plugin,
                                              site_.SchemeIs(kGuestScheme));
       }
     }
     CHECK(process_);
+    if (!process_->HasObserver(this))
+      process_->AddObserver(this);

[Avi (use Gerrit), 2013/11/14 03:32:27]

Yeah, that's bogus. I'll fix that tomorrow.

 
     // If we are using process-per-site, we need to register this process
     // for the current site so that we can find it again.  (If no site is set
     // at this time, we will register it in SetSite().)
     if (use_process_per_site) {
       RenderProcessHostImpl::RegisterProcessHostForSite(browser_context,
                                                         process_, site_);
     }
 
     GetContentClient()->browser()->SiteInstanceGotProcess(this);
@@ skipping 177 matching lines @@
   return site;
 }
 
 /*static*/
 GURL SiteInstanceImpl::GetEffectiveURL(BrowserContext* browser_context,
                                        const GURL& url) {
   return GetContentClient()->browser()->
       GetEffectiveURL(browser_context, url);
 }
 
-void SiteInstanceImpl::Observe(int type,
-                               const NotificationSource& source,
-                               const NotificationDetails& details) {
-  DCHECK(type == NOTIFICATION_RENDERER_PROCESS_TERMINATED);
-  RenderProcessHost* rph = Source<RenderProcessHost>(source).ptr();
-  if (rph == process_)
-    process_ = NULL;
+void SiteInstanceImpl::RenderProcessHostDestroyed(RenderProcessHost* host) {
+  DCHECK_EQ(process_, host);
+  process_->RemoveObserver(this);
+  process_ = NULL;
 }
 
 void SiteInstanceImpl::LockToOrigin() {
   // We currently only restrict this process to a particular site if the
   // --enable-strict-site-isolation or --site-per-process flags are present.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableStrictSiteIsolation) ||
       command_line.HasSwitch(switches::kSitePerProcess)) {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     policy->LockToOrigin(process_->GetID(), site_);
   }
 }
 
 }  // namespace content