Remove EPM:all_hosts_ and use all_extension_views_ instead.

chrome/browser/extensions/extension_browsertest.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/extensions/extension_browsertest.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/extensions/app_shortcut_manager.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
-#include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_view_host.h"
 
 ExtensionBrowserTest::ExtensionBrowserTest()
     : loaded_(false),
       installed_(false),
       extension_installs_observed_(0),
       extension_load_errors_observed_(0),
       target_page_action_count_(-1),
       target_visible_page_action_count_(-1) {
   EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   AppShortcutManager::SetShortcutCreationDisabledForTesting(true);
@@ skipping 83 matching lines @@
     CHECK(service->AllowFileAccess(extension));
 
     if (!fileaccess_enabled) {
       service->SetAllowFileAccess(extension, fileaccess_enabled);
       load_signal.Wait();
       extension = service->GetExtensionById(extension_id, false);
       CHECK(extension) << extension_id << " not found after reloading.";
     }
   }
 
-  if (!WaitForExtensionHostsToLoad())
+  if (!WaitForExtensionViewsToLoad())
     return NULL;
 
   return extension;
 }
 
 const Extension* ExtensionBrowserTest::LoadExtension(const FilePath& path) {
   return LoadExtensionWithOptions(path, false, true);
 }
 
 const Extension* ExtensionBrowserTest::LoadExtensionIncognito(
@@ skipping 175 matching lines @@
     VLOG(1) << "Errors follow:";
     const std::vector<string16>* errors =
         ExtensionErrorReporter::GetInstance()->GetErrors();
     for (std::vector<string16>::const_iterator iter = errors->begin();
          iter != errors->end(); ++iter)
       VLOG(1) << *iter;
 
     return NULL;
   }
 
-  if (!WaitForExtensionHostsToLoad())
+  if (!WaitForExtensionViewsToLoad())
     return NULL;
   return service->GetExtensionById(last_loaded_extension_id_, false);
 }
 
 void ExtensionBrowserTest::ReloadExtension(const std::string& extension_id) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->ReloadExtension(extension_id);
   ui_test_utils::RegisterAndWait(this,
                                  chrome::NOTIFICATION_EXTENSION_LOADED,
                                  content::NotificationService::AllSources());
@@ skipping 36 matching lines @@
       browser()->window()->GetLocationBar()->GetLocationBarForTesting();
   if (location_bar->PageActionVisibleCount() != count) {
     target_visible_page_action_count_ = count;
     ui_test_utils::RegisterAndWait(this,
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
         content::NotificationService::AllSources());
   }
   return location_bar->PageActionVisibleCount() == count;
 }
 
-bool ExtensionBrowserTest::WaitForExtensionHostsToLoad() {
-  // Wait for all the extension hosts that exist to finish loading.
+bool ExtensionBrowserTest::WaitForExtensionViewsToLoad() {
+  // Wait for all the extension render view hosts that exist to finish loading.
   content::NotificationRegistrar registrar;
-  registrar.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
+  registrar.Add(this, content::NOTIFICATION_LOAD_STOP,
                 content::NotificationService::AllSources());
 
   ExtensionProcessManager* manager =
         browser()->profile()->GetExtensionProcessManager();
-  for (ExtensionProcessManager::const_iterator iter = manager->begin();
-       iter != manager->end();) {
-    if ((*iter)->did_stop_loading()) {
+  ExtensionProcessManager::ViewSet all_views = manager->GetAllViews();
+  for (ExtensionProcessManager::ViewSet::const_iterator iter =
+           all_views.begin();
+       iter != all_views.end();) {
+    if (!(*iter)->IsLoading()) {
       ++iter;
     } else {
       ui_test_utils::RunMessageLoop();
 
       // Test activity may have modified the set of extension processes during
       // message processing, so re-start the iteration to catch added/removed
       // processes.
-      iter = manager->begin();
+      iter = all_views.begin();

[Matt Perry, 2012/04/23 21:53:04]

Given the comment, this should be:
all_views = manager->GetAllViews();
iter = all_views.begin();

[benwells, 2012/04/24 04:31:27]

Done.

     }
   }
   return true;
 }
 
 bool ExtensionBrowserTest::WaitForExtensionInstall() {
   int before = extension_installs_observed_;
   ui_test_utils::RegisterAndWait(this,
                                  chrome::NOTIFICATION_EXTENSION_INSTALLED,
                                  content::NotificationService::AllSources());
   return extension_installs_observed_ == (before + 1);
 }
 
 bool ExtensionBrowserTest::WaitForExtensionInstallError() {
   int before = extension_installs_observed_;
   ui_test_utils::RegisterAndWait(this,
                                  chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                                  content::NotificationService::AllSources());
   return extension_installs_observed_ == before;
 }
 
 void ExtensionBrowserTest::WaitForExtensionLoad() {
   ui_test_utils::RegisterAndWait(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                                  content::NotificationService::AllSources());
-  WaitForExtensionHostsToLoad();
+  WaitForExtensionViewsToLoad();
 }
 
 bool ExtensionBrowserTest::WaitForExtensionLoadError() {
   int before = extension_load_errors_observed_;
   ui_test_utils::RegisterAndWait(this,
                                  chrome::NOTIFICATION_EXTENSION_LOAD_ERROR,
                                  content::NotificationService::AllSources());
   return extension_load_errors_observed_ != before;
 }
 
@@ skipping 29 matching lines @@
         const Extension* extension =
             content::Details<const Extension>(details).ptr();
         if (extension)
           last_loaded_extension_id_ = extension->id();
         else
           last_loaded_extension_id_ = "";
       }
       MessageLoopForUI::current()->Quit();
       break;
 
-    case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
-      VLOG(1) << "Got EXTENSION_HOST_DID_STOP_LOADING notification.";
-      MessageLoopForUI::current()->Quit();
-      break;
-
     case chrome::NOTIFICATION_EXTENSION_INSTALLED:
       VLOG(1) << "Got EXTENSION_INSTALLED notification.";
       ++extension_installs_observed_;
       MessageLoopForUI::current()->Quit();
       break;
 
     case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR:
       VLOG(1) << "Got EXTENSION_INSTALL_ERROR notification.";
       MessageLoopForUI::current()->Quit();
       break;
@@ skipping 29 matching lines @@
                  "Number of visible page actions: "
               << location_bar->PageActionVisibleCount();
       if (location_bar->PageActionVisibleCount() ==
           target_visible_page_action_count_) {
         target_visible_page_action_count_ = -1;
         MessageLoopForUI::current()->Quit();
       }
       break;
     }
 
+    case content::NOTIFICATION_LOAD_STOP:
+      VLOG(1) << "Got LOAD_STOP notification.";
+      MessageLoopForUI::current()->Quit();
+      break;
+
     default:
       NOTREACHED();
       break;
   }
 }