Improve ExtensionBrowserTest. Part of moving ExtensionService to use ExtensionSet.

chrome/browser/extensions/extension_browsertest.cc

 // Copyright (c) 2011 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"
@@ skipping 211 matching lines @@
  public:
   explicit MockAutoConfirmExtensionInstallUI(Profile* profile) :
       ExtensionInstallUI(profile) {}
 
   // Proceed without confirmation prompt.
   virtual void ConfirmInstall(Delegate* delegate, const Extension* extension) {
     delegate->InstallUIProceed();
   }
 };
 
-bool ExtensionBrowserTest::InstallExtensionFromWebstore(const FilePath& path,
-                                                        int expected_change) {
+const Extension* ExtensionBrowserTest::InstallExtensionFromWebstore(
+    const FilePath& path,
+    int expected_change) {
   return InstallOrUpdateExtension("", path, INSTALL_UI_TYPE_NONE,
                                   expected_change, browser()->profile(),
                                   true);
 }
 
-bool ExtensionBrowserTest::InstallOrUpdateExtension(const std::string& id,
-                                                    const FilePath& path,
-                                                    InstallUIType ui_type,
-                                                    int expected_change) {
+const Extension* ExtensionBrowserTest::InstallOrUpdateExtension(
+    const std::string& id,
+    const FilePath& path,
+    InstallUIType ui_type,
+    int expected_change) {
   return InstallOrUpdateExtension(id, path, ui_type, expected_change,
                                   browser()->profile(), false);
 }
 
-bool ExtensionBrowserTest::InstallOrUpdateExtension(const std::string& id,
-                                                    const FilePath& path,
-                                                    InstallUIType ui_type,
-                                                    int expected_change,
-                                                    Profile* profile,
-                                                    bool from_webstore) {
+const Extension* ExtensionBrowserTest::InstallOrUpdateExtension(
+    const std::string& id,
+    const FilePath& path,
+    InstallUIType ui_type,
+    int expected_change,
+    Profile* profile,
+    bool from_webstore) {
   ExtensionService* service = profile->GetExtensionService();
   service->set_show_extensions_prompts(false);
   size_t num_before = service->extensions()->size();
 
   {
-    content::NotificationRegistrar registrar;
-    registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
-                  content::NotificationService::AllSources());
-    registrar.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
-                  content::NotificationService::AllSources());
-    registrar.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
-                  content::NotificationService::AllSources());
-    registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOAD_ERROR,
-                  content::NotificationService::AllSources());
-
     ExtensionInstallUI* install_ui = NULL;
     if (ui_type == INSTALL_UI_TYPE_CANCEL)
       install_ui = new MockAbortExtensionInstallUI();
     else if (ui_type == INSTALL_UI_TYPE_NORMAL)
       install_ui = new ExtensionInstallUI(profile);
     else if (ui_type == INSTALL_UI_TYPE_AUTO_CONFIRM)
       install_ui = new MockAutoConfirmExtensionInstallUI(profile);
 
     // TODO(tessamac): Update callers to always pass an unpacked extension
     //                 and then always pack the extension here.
     FilePath crx_path = path;
     if (crx_path.Extension() != FILE_PATH_LITERAL(".crx")) {
       crx_path = PackExtension(path);
     }
     if (crx_path.empty())
-      return false;
+      return NULL;
 
     scoped_refptr<CrxInstaller> installer(
         CrxInstaller::Create(service, install_ui));
     installer->set_expected_id(id);
     installer->set_is_gallery_install(from_webstore);
+
+    content::NotificationRegistrar registrar;
+    registrar.Add(this, chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+                  content::Source<CrxInstaller>(installer.get()));
+
     installer->InstallCrx(crx_path);
 
     ui_test_utils::RunMessageLoop();
   }
 
   size_t num_after = service->extensions()->size();
-  if (num_after != (num_before + expected_change)) {
+  EXPECT_EQ(num_before + expected_change, num_after);
+  if (num_before + expected_change != num_after) {
     VLOG(1) << "Num extensions before: " << base::IntToString(num_before)
             << " num after: " << base::IntToString(num_after)
             << " Installed extensions follow:";
 
     for (size_t i = 0; i < service->extensions()->size(); ++i)
       VLOG(1) << "  " << (*service->extensions())[i]->id();
 
     VLOG(1) << "Errors follow:";
     const std::vector<std::string>* errors =
         ExtensionErrorReporter::GetInstance()->GetErrors();
     for (std::vector<std::string>::const_iterator iter = errors->begin();
          iter != errors->end(); ++iter)
       VLOG(1) << *iter;
 
-    return false;
+    return NULL;
   }
 
-  return WaitForExtensionHostsToLoad();
+  if (!WaitForExtensionHostsToLoad())
+    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 106 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED:
       last_loaded_extension_id_ =
           content::Details<const Extension>(details).ptr()->id();
       VLOG(1) << "Got EXTENSION_LOADED notification.";
       MessageLoopForUI::current()->Quit();
       break;
 
-    case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
-      VLOG(1) << "Got EXTENSION_UPDATE_DISABLED notification.";
+    case chrome::NOTIFICATION_CRX_INSTALLER_DONE:
+      VLOG(1) << "Got CRX_INSTALLER_DONE notification.";
+      {
+        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_LOAD_ERROR:
-      VLOG(1) << "Got EXTENSION_LOAD_ERROR notification.";
-      MessageLoopForUI::current()->Quit();
-      break;
-
     case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR:
       VLOG(1) << "Got EXTENSION_INSTALL_ERROR notification.";
       MessageLoopForUI::current()->Quit();
       break;
 
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED:
       VLOG(1) << "Got EXTENSION_PROCESS_TERMINATED notification.";
       MessageLoopForUI::current()->Quit();
       break;
 
@@ skipping 22 matching lines @@
         MessageLoopForUI::current()->Quit();
       }
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }