content: Remove usage of NOTIFICATION_WEB_CONTENTS_DESTROYED from content

content/browser/web_contents/web_contents_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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 266 matching lines @@
   }
 
   new_contents->Init(params);
   return new_contents;
 }
 
 WebContents* WebContents::FromRenderViewHost(const RenderViewHost* rvh) {
   return rvh->GetDelegate()->GetAsWebContents();
 }
 
+// WebContentsImpl::DestructionObserver ----------------------------------------
+
+class WebContentsImpl::DestructionObserver : public WebContentsObserver {
+ public:
+  DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
+      : WebContentsObserver(watched_contents),
+        owner_(owner) {
+  }
+
+  // WebContentsObserver:
+  virtual void WebContentsDestroyed(WebContents* web_contents) OVERRIDE {
+    owner_->OnWebContentsDestroyed(static_cast<WebContentsImpl*>(web_contents));
+  }
+
+ private:
+  WebContentsImpl* owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
+};
+
 // WebContentsImpl -------------------------------------------------------------
 
 WebContentsImpl::WebContentsImpl(
     BrowserContext* browser_context,
     WebContentsImpl* opener)
     : delegate_(NULL),
       controller_(this, browser_context),
       render_view_host_delegate_view_(NULL),
       opener_(opener),
 #if defined(OS_WIN) && defined(USE_AURA)
@@ skipping 67 matching lines @@
       unload_start_time = before_unload_end_time_;
     UMA_HISTOGRAM_TIMES("Tab.Close", now - close_start_time_);
     UMA_HISTOGRAM_TIMES("Tab.Close.UnloadTime", now - unload_start_time);
   }
 
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     WebContentsImplDestroyed());
 
   SetDelegate(NULL);
+
+  STLDeleteContainerPairSecondPointers(destruction_observers_.begin(),
+                                       destruction_observers_.end());
 }
 
 WebContentsImpl* WebContentsImpl::CreateWithOpener(
     const WebContents::CreateParams& params,
     WebContentsImpl* opener) {
   WebContentsImpl* new_contents = new WebContentsImpl(
       params.browser_context, opener);
 
   new_contents->Init(params);
   return new_contents;
@@ skipping 722 matching lines @@
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     DidCloneToNewWebContents(this, tc));
   return tc;
 }
 
 void WebContentsImpl::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   switch (type) {
-    case NOTIFICATION_WEB_CONTENTS_DESTROYED:
-      OnWebContentsDestroyed(Source<WebContents>(source).ptr());
-      break;
     case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
       RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
       for (PendingWidgetViews::iterator i = pending_widget_views_.begin();
            i != pending_widget_views_.end(); ++i) {
         if (host->GetView() == i->second) {
           pending_widget_views_.erase(i);
           break;
         }
       }
       break;
@@ skipping 29 matching lines @@
           this, delegate, &render_view_host_delegate_view_));
     }
     CHECK(render_view_host_delegate_view_);
   }
   CHECK(view_.get());
 
   gfx::Size initial_size = params.initial_size;
   view_->CreateView(initial_size, params.context);
 
   // Listen for whether our opener gets destroyed.
-  if (opener_) {
-    registrar_.Add(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                   Source<WebContents>(opener_));
-  }
+  if (opener_)
+    AddDestructionObserver(opener_);
 
   registrar_.Add(this,
                  NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
                  NotificationService::AllBrowserContextsAndSources());
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_host_manager_.reset(
       new JavaBridgeDispatcherHostManager(this));
 #endif
 
 #if defined(OS_ANDROID)
   date_time_chooser_.reset(new DateTimeChooserAndroid());
 #endif
 }
 
-void WebContentsImpl::OnWebContentsDestroyed(WebContents* web_contents) {
+void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
+  RemoveDestructionObserver(web_contents);
+
   // Clear the opener if it has been closed.
   if (web_contents == opener_) {
-    registrar_.Remove(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                      Source<WebContents>(opener_));
     opener_ = NULL;
     return;
   }
   // Clear a pending contents that has been closed before being shown.
   for (PendingContents::iterator iter = pending_contents_.begin();
        iter != pending_contents_.end();
        ++iter) {
     if (iter->second != web_contents)
       continue;
     pending_contents_.erase(iter);
-    registrar_.Remove(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                      Source<WebContents>(web_contents));
     return;
   }
   NOTREACHED();
 }
 
+void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
+  if (!ContainsKey(destruction_observers_, web_contents)) {
+    destruction_observers_[web_contents] =
+        new DestructionObserver(this, web_contents);
+  }
+}
+
+void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
+  DestructionObservers::iterator iter =
+      destruction_observers_.find(web_contents);
+  if (iter != destruction_observers_.end()) {
+    delete destruction_observers_[web_contents];
+    destruction_observers_.erase(iter);
+  }
+}
+
 void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WebContentsImpl::Activate() {
   if (delegate_)
@@ skipping 188 matching lines @@
       WebContentsViewPort* new_view = new_contents->view_.get();
 
       // TODO(brettw): It seems bogus that we have to call this function on the
       // newly created object and give it one of its own member variables.
       new_view->CreateViewForWidget(new_contents->GetRenderViewHost());
     }
     // Save the created window associated with the route so we can show it
     // later.
     DCHECK_NE(MSG_ROUTING_NONE, route_id);
     pending_contents_[route_id] = new_contents;
-    registrar_.Add(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                   Source<WebContents>(new_contents));
+    AddDestructionObserver(new_contents);
   }
 
   if (delegate_) {
     delegate_->WebContentsCreated(
         this, params.opener_frame_id, params.frame_name,
         params.target_url, new_contents);
   }
 
   if (params.opener_suppressed) {
     // When the opener is suppressed, the original renderer cannot access the
@@ skipping 114 matching lines @@
   PendingContents::iterator iter = pending_contents_.find(route_id);
 
   // Certain systems can block the creation of new windows. If we didn't succeed
   // in creating one, just return NULL.
   if (iter == pending_contents_.end()) {
     return NULL;
   }
 
   WebContentsImpl* new_contents = iter->second;
   pending_contents_.erase(route_id);
-  registrar_.Remove(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                    Source<WebContents>(new_contents));
+  RemoveDestructionObserver(new_contents);
 
   // Don't initialize the guest WebContents immediately.
   if (new_contents->GetRenderProcessHost()->IsGuest())
     return new_contents;
 
   if (!new_contents->GetRenderProcessHost()->HasConnection() ||
       !new_contents->GetRenderViewHost()->GetView())
     return NULL;
 
   // TODO(brettw): It seems bogus to reach into here and initialize the host.
@@ skipping 1426 matching lines @@
 #if defined(OS_ANDROID)
   if (delegate_)
     delegate_->LoadProgressChanged(this, progress);
 #endif
 }
 
 void WebContentsImpl::DidDisownOpener(RenderViewHost* rvh) {
   if (opener_) {
     // Clear our opener so that future cross-process navigations don't have an
     // opener assigned.
-    registrar_.Remove(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                      Source<WebContents>(opener_));
+    RemoveDestructionObserver(opener_);
     opener_ = NULL;
   }
 
   // Notify all swapped out RenderViewHosts for this tab.  This is important
   // in case we go back to them, or if another window in those processes tries
   // to access window.opener.
   render_manager_.DidDisownOpener(rvh);
 }
 
 void WebContentsImpl::DocumentAvailableInMainFrame(
@@ skipping 512 matching lines @@
 }
 
 BrowserPluginGuestManager*
     WebContentsImpl::GetBrowserPluginGuestManager() const {
   return static_cast<BrowserPluginGuestManager*>(
       GetBrowserContext()->GetUserData(
           browser_plugin::kBrowserPluginGuestManagerKeyName));
 }
 
 }  // namespace content