Remove NOTIFICATION_RENDER_VIEW_HOST_CHANGED.

chrome/browser/speech/chrome_speech_recognition_manager_delegate.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/speech/chrome_speech_recognition_manager_delegate.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_registrar.h"
-#include "content/public/browser/notification_source.h"
-#include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/speech_recognition_manager.h"
 #include "content/public/browser/speech_recognition_session_config.h"
 #include "content/public/browser/speech_recognition_session_context.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_WIN)
 #include "chrome/installer/util/wmi.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 89 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(OptionalRequestInfo);
 };
 
 // Simple utility to get notified when a WebContent (a tab or an extension's
 // background page) is closed or crashes. The callback will always be called on
 // the UI thread.
 // There is no restriction on the constructor, however this class must be
 // destroyed on the UI thread, due to the NotificationRegistrar dependency.
 class ChromeSpeechRecognitionManagerDelegate::TabWatcher
-    : public base::RefCountedThreadSafe<TabWatcher>,
-      public content::NotificationObserver {
+    : public base::RefCountedThreadSafe<TabWatcher> {
  public:
   typedef base::Callback<void(int render_process_id, int render_view_id)>
       TabClosedCallback;
 
   explicit TabWatcher(TabClosedCallback tab_closed_callback)
       : tab_closed_callback_(tab_closed_callback) {
   }
 
   // Starts monitoring the WebContents corresponding to the given
   // |render_process_id|, |render_view_id| pair, invoking |tab_closed_callback_|
   // if closed/unloaded.
   void Watch(int render_process_id, int render_view_id) {
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
           &TabWatcher::Watch, this, render_process_id, render_view_id));
       return;
     }
 
     WebContents* web_contents = tab_util::GetWebContentsByID(render_process_id,
                                                              render_view_id);
     // Sessions initiated by speech input extension APIs will end up in a NULL
     // WebContent here, but they are properly managed by the
     // chrome::SpeechInputExtensionManager. However, sessions initiated within a
     // extension using the (new) speech JS APIs, will be properly handled here.
     // TODO(primiano) turn this line into a DCHECK once speech input extension
     // API is deprecated.
     if (!web_contents)
       return;
 
-    // Avoid multiple registrations on |registrar_| for the same |web_contents|.
+    // Avoid multiple registrations for the same |web_contents|.
     if (FindWebContents(web_contents) !=  registered_web_contents_.end()) {
       return;
     }
-    registered_web_contents_.push_back(
-        WebContentsInfo(web_contents, render_process_id, render_view_id));
-
-    // Lazy initialize the registrar.
-    if (!registrar_.get())
-      registrar_.reset(new content::NotificationRegistrar());
-
-    registrar_->Add(this,
-                    content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
-                    content::Source<WebContents>(web_contents));
-    registrar_->Add(this,
-                    content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
-                    content::Source<WebContents>(web_contents));
+    registered_web_contents_.push_back(new WebContentsTracker(
+        web_contents, base::Bind(&TabWatcher::OnTabClosed,
+                                 // |this| outlives WebContentsTracker.
+                                 base::Unretained(this), web_contents),
+        render_process_id, render_view_id));
   }
 
-  // content::NotificationObserver implementation.
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override {
-    DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    DCHECK(type == content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED ||
-           type == content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED);
-
-    WebContents* web_contents = content::Source<WebContents>(source).ptr();
-    std::vector<WebContentsInfo>::iterator iter = FindWebContents(web_contents);
+  void OnTabClosed(content::WebContents* web_contents) {
+    ScopedVector<WebContentsTracker>::iterator iter =
+        FindWebContents(web_contents);
     DCHECK(iter != registered_web_contents_.end());
-    int render_process_id = iter->render_process_id;
-    int render_view_id = iter->render_view_id;
+    int render_process_id = (*iter)->render_process_id();
+    int render_view_id = (*iter)->render_view_id();
     registered_web_contents_.erase(iter);
 
-    registrar_->Remove(this,
-                       content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
-                       content::Source<WebContents>(web_contents));
-    registrar_->Remove(this,
-                       content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
-                       content::Source<WebContents>(web_contents));
-
     tab_closed_callback_.Run(render_process_id, render_view_id);
   }
 
  private:
-  struct WebContentsInfo {
-    WebContentsInfo(content::WebContents* web_contents,
-                    int render_process_id,
-                    int render_view_id)
-        : web_contents(web_contents),
-          render_process_id(render_process_id),
-          render_view_id(render_view_id) {}
+  class WebContentsTracker : public content::WebContentsObserver {
+   public:
+    WebContentsTracker(content::WebContents* web_contents,
+                       const base::Closure& finished_callback,
+                       int render_process_id,
+                       int render_view_id)
+        : content::WebContentsObserver(web_contents),
+          finished_callback_(finished_callback),
+          render_process_id_(render_process_id),
+          render_view_id_(render_view_id) {}
 
-    ~WebContentsInfo() {}
+    ~WebContentsTracker() override {}
 
-    content::WebContents* web_contents;
-    int render_process_id;
-    int render_view_id;
+    int render_process_id() const { return render_process_id_; }
+    int render_view_id() const { return render_view_id_; }
+
+   private:
+    // content::WebContentsObserver overrides.
+    void WebContentsDestroyed() override {
+      Observe(nullptr);
+      finished_callback_.Run();
+      // NOTE: We are deleted now.
+    }
+    void RenderViewHostChanged(content::RenderViewHost* old_host,
+                               content::RenderViewHost* new_host) override {
+      Observe(nullptr);
+      finished_callback_.Run();
+      // NOTE: We are deleted now.
+    }
+
+    const base::Closure finished_callback_;
+    const int render_process_id_;
+    const int render_view_id_;
   };
 
   friend class base::RefCountedThreadSafe<TabWatcher>;
 
-  ~TabWatcher() override {
+  ~TabWatcher() {
     // Must be destroyed on the UI thread due to |registrar_| non thread-safety.
+    // TODO(lazyboy): Do we still need this?
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
   }
 
   // Helper function to find the iterator in |registered_web_contents_| which
   // contains |web_contents|.
-  std::vector<WebContentsInfo>::iterator FindWebContents(
+  ScopedVector<WebContentsTracker>::iterator FindWebContents(
       content::WebContents* web_contents) {
-    for (std::vector<WebContentsInfo>::iterator i(
-         registered_web_contents_.begin());
+    for (ScopedVector<WebContentsTracker>::iterator i(
+             registered_web_contents_.begin());
          i != registered_web_contents_.end(); ++i) {
-      if (i->web_contents == web_contents)
+      if ((*i)->web_contents() == web_contents)
         return i;
     }
 
     return registered_web_contents_.end();
   }
 
-  // Lazy-initialized and used on the UI thread to handle web contents
-  // notifications (tab closing).
-  scoped_ptr<content::NotificationRegistrar> registrar_;
-
   // Keeps track of which WebContent(s) have been registered, in order to avoid
-  // double registrations on |registrar_| and to pass the correct render
+  // double registrations on WebContentsObserver and to pass the correct render
   // process id and render view id to |tab_closed_callback_| after the process
   // has gone away.
-  std::vector<WebContentsInfo> registered_web_contents_;
+  ScopedVector<WebContentsTracker> registered_web_contents_;
 
   // Callback used to notify, on the thread specified by |callback_thread_| the
   // closure of a registered tab.
   TabClosedCallback tab_closed_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TabWatcher);
 };
 
 ChromeSpeechRecognitionManagerDelegate
 ::ChromeSpeechRecognitionManagerDelegate() {
@@ skipping 163 matching lines @@
   // Otherwise this should be a regular tab contents.
   allowed = true;
   check_permission = true;
 #endif
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, check_permission, allowed));
 }
 
 }  // namespace speech