Make ExtensionService use ExtensionSet.

chrome/browser/extensions/extension_browsertests_misc.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 "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/autoupdate_interceptor.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
@@ skipping 194 matching lines @@
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, PageActionRefreshCrash) {
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   ExtensionService* service = browser()->profile()->GetExtensionService();
 
   size_t size_before = service->extensions()->size();
 
   FilePath base_path = test_data_dir_.AppendASCII("browsertest")
                                      .AppendASCII("crash_44415");
   // Load extension A.
-  ASSERT_TRUE(LoadExtension(base_path.AppendASCII("ExtA")));
+  const Extension* extensionA = LoadExtension(base_path.AppendASCII("ExtA"));
+  ASSERT_TRUE(extensionA);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
   ASSERT_EQ(size_before + 1, service->extensions()->size());
-  const Extension* extensionA = service->extensions()->at(size_before);
 
   LOG(INFO) << "Load extension A done  : "
             << (base::TimeTicks::Now() - start_time).InMilliseconds()
             << " ms" << std::flush;
 
   // Load extension B.
-  ASSERT_TRUE(LoadExtension(base_path.AppendASCII("ExtB")));
+  const Extension* extensionB = LoadExtension(base_path.AppendASCII("ExtB"));
+  ASSERT_TRUE(extensionB);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(2));
   ASSERT_EQ(size_before + 2, service->extensions()->size());
-  const Extension* extensionB = service->extensions()->at(size_before + 1);
 
   LOG(INFO) << "Load extension B done  : "
             << (base::TimeTicks::Now() - start_time).InMilliseconds()
             << " ms" << std::flush;
 
+  std::string idA = extensionA->id();
   ReloadExtension(extensionA->id());
   // ExtensionA has changed, so refetch it.
   ASSERT_EQ(size_before + 2, service->extensions()->size());
-  extensionA = service->extensions()->at(size_before + 1);
+  extensionA = service->extensions()->GetByID(idA);
 
   LOG(INFO) << "Reload extension A done: "
             << (base::TimeTicks::Now() - start_time).InMilliseconds()
             << " ms" << std::flush;
 
   ReloadExtension(extensionB->id());
 
   LOG(INFO) << "Reload extension B done: "
             << (base::TimeTicks::Now() - start_time).InMilliseconds()
             << " ms" << std::flush;
@@ skipping 23 matching lines @@
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 }
 
 // Tests that tooltips of a browser action icon can be specified using UTF8.
 // See http://crbug.com/25349.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, TitleLocalizationBrowserAction) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   const size_t size_before = service->extensions()->size();
   FilePath extension_path(test_data_dir_.AppendASCII("browsertest")
                                         .AppendASCII("title_localized"));
-  ASSERT_TRUE(LoadExtension(extension_path));
+  const Extension* extension = LoadExtension(extension_path);
+  ASSERT_TRUE(extension);
 
   ASSERT_EQ(size_before + 1, service->extensions()->size());
-  const Extension* extension = service->extensions()->at(size_before);
 
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur: l10n browser action").c_str(),
                extension->description().c_str());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
                extension->name().c_str());
   int tab_id = ExtensionTabUtil::GetTabId(browser()->GetSelectedTabContents());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
                extension->browser_action()->GetTitle(tab_id).c_str());
 }
 
 // Tests that tooltips of a page action icon can be specified using UTF8.
 // See http://crbug.com/25349.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, TitleLocalizationPageAction) {
   ASSERT_TRUE(test_server()->Start());
 
   ExtensionService* service = browser()->profile()->GetExtensionService();
   const size_t size_before = service->extensions()->size();
 
   FilePath extension_path(test_data_dir_.AppendASCII("browsertest")
                                         .AppendASCII("title_localized_pa"));
-  ASSERT_TRUE(LoadExtension(extension_path));
+  const Extension* extension = LoadExtension(extension_path);
+  ASSERT_TRUE(extension);
 
   // Any navigation prompts the location bar to load the page action.
   GURL url = test_server()->GetURL(kLocalization);
   ui_test_utils::NavigateToURL(browser(), url);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 
   ASSERT_EQ(size_before + 1, service->extensions()->size());
-  const Extension* extension = service->extensions()->at(size_before);
 
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur: l10n page action").c_str(),
                extension->description().c_str());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
                extension->name().c_str());
   int tab_id = ExtensionTabUtil::GetTabId(browser()->GetSelectedTabContents());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
                extension->page_action()->GetTitle(tab_id).c_str());
 }
 
@@ skipping 56 matching lines @@
   return expected_value == returned_value;
 }
 
 // Navigates to a feed page and, if |sniff_xml_type| is set, wait for the
 // extension to kick in, detect the feed and redirect to a feed preview page.
 // |sniff_xml_type| is generally set to true if the feed is sniffable and false
 // for invalid feeds.
 void NavigateToFeedAndValidate(net::TestServer* server,
                                const std::string& url,
                                Browser* browser,
+                               std::string extension_id,
                                bool sniff_xml_type,
                                const std::string& expected_feed_title,
                                const std::string& expected_item_title,
                                const std::string& expected_item_desc,
                                const std::string& expected_error) {
   if (sniff_xml_type) {
     // TODO(finnur): Implement this is a non-flaky way.
   }
 
-  ExtensionService* service = browser->profile()->GetExtensionService();
-  const Extension* extension = service->extensions()->back();
-  std::string id = extension->id();
-
   // Navigate to the subscribe page directly.
-  ui_test_utils::NavigateToURL(browser, GetFeedUrl(server, url, true, id));
+  ui_test_utils::NavigateToURL(browser,
+                               GetFeedUrl(server, url, true, extension_id));
 
   TabContents* tab = browser->GetSelectedTabContents();
   ASSERT_TRUE(ValidatePageElement(tab,
                                   L"",
                                   jscript_feed_title,
                                   expected_feed_title));
   ASSERT_TRUE(ValidatePageElement(tab,
                                   L"//html/body/div/iframe[1]",
                                   jscript_anchor,
                                   expected_item_title));
   ASSERT_TRUE(ValidatePageElement(tab,
                                   L"//html/body/div/iframe[1]",
                                   jscript_desc,
                                   expected_item_desc));
   ASSERT_TRUE(ValidatePageElement(tab,
                                   L"//html/body/div/iframe[1]",
                                   jscript_error,
                                   expected_error));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeed1) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
-  NavigateToFeedAndValidate(test_server(), kValidFeed1, browser(), true,
+  NavigateToFeedAndValidate(test_server(), kValidFeed1, browser(), id, true,
                             "Feed for MyFeedTitle",
                             "Title 1",
                             "Desc",
                             "No error");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeed2) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
-  NavigateToFeedAndValidate(test_server(), kValidFeed2, browser(), true,
+  NavigateToFeedAndValidate(test_server(), kValidFeed2, browser(), id, true,
                             "Feed for MyFeed2",
                             "My item title1",
                             "This is a summary.",
                             "No error");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeed3) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
-  NavigateToFeedAndValidate(test_server(), kValidFeed3, browser(), true,
+  NavigateToFeedAndValidate(test_server(), kValidFeed3, browser(), id, true,
                             "Feed for Google Code buglist rss feed",
                             "My dear title",
                             "My dear content",
                             "No error");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeed4) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
-  NavigateToFeedAndValidate(test_server(), kValidFeed4, browser(), true,
+  NavigateToFeedAndValidate(test_server(), kValidFeed4, browser(), id, true,
                             "Feed for Title chars <script> %23 stop",
                             "Title chars  %23 stop",
                             "My dear content %23 stop",
                             "No error");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeed0) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // Try a feed with a link with an onclick handler (before r27440 this would
   // trigger a NOTREACHED).
-  NavigateToFeedAndValidate(test_server(), kValidFeed0, browser(), true,
+  NavigateToFeedAndValidate(test_server(), kValidFeed0, browser(), id, true,
                             "Feed for MyFeedTitle",
                             "Title 1",
                             "Desc VIDEO",
                             "No error");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeed5) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // Feed with valid but mostly empty xml.
-  NavigateToFeedAndValidate(test_server(), kValidFeed5, browser(), true,
+  NavigateToFeedAndValidate(test_server(), kValidFeed5, browser(), id, true,
                             "Feed for Unknown feed name",
                             "element 'anchor_0' not found",
                             "element 'desc_0' not found",
                             "This feed contains no entries.");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeed6) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // Feed that is technically invalid but still parseable.
-  NavigateToFeedAndValidate(test_server(), kValidFeed6, browser(), true,
+  NavigateToFeedAndValidate(test_server(), kValidFeed6, browser(), id, true,
                             "Feed for MyFeedTitle",
                             "Title 1",
                             "Desc",
                             "No error");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedInvalidFeed1) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // Try an empty feed.
-  NavigateToFeedAndValidate(test_server(), kInvalidFeed1, browser(), false,
+  NavigateToFeedAndValidate(test_server(), kInvalidFeed1, browser(), id, false,
                             "Feed for Unknown feed name",
                             "element 'anchor_0' not found",
                             "element 'desc_0' not found",
                             "This feed contains no entries.");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedInvalidFeed2) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // Try a garbage feed.
-  NavigateToFeedAndValidate(test_server(), kInvalidFeed2, browser(), false,
+  NavigateToFeedAndValidate(test_server(), kInvalidFeed2, browser(), id, false,
                             "Feed for Unknown feed name",
                             "element 'anchor_0' not found",
                             "element 'desc_0' not found",
                             "This feed contains no entries.");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedInvalidFeed3) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // Try a feed that doesn't exist.
-  NavigateToFeedAndValidate(test_server(), "foo.xml", browser(), false,
+  NavigateToFeedAndValidate(test_server(), "foo.xml", browser(), id, false,
                             "Feed for Unknown feed name",
                             "element 'anchor_0' not found",
                             "element 'desc_0' not found",
                             "This feed contains no entries.");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedInvalidFeed4) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // subscribe.js shouldn't double-decode the URL passed in. Otherwise feed
   // links such as http://search.twitter.com/search.atom?lang=en&q=%23chrome
   // will result in no feed being downloaded because %23 gets decoded to # and
   // therefore #chrome is not treated as part of the Twitter query. This test
   // uses an underscore instead of a hash, but the principle is the same. If
   // we start erroneously double decoding again, the path (and the feed) will
   // become valid resulting in a failure for this test.
-  NavigateToFeedAndValidate(test_server(), kFeedTripleEncoded, browser(), true,
-                            "Feed for Unknown feed name",
-                            "element 'anchor_0' not found",
-                            "element 'desc_0' not found",
-                            "This feed contains no entries.");
+  NavigateToFeedAndValidate(
+      test_server(), kFeedTripleEncoded, browser(), id, true,
+      "Feed for Unknown feed name",
+      "element 'anchor_0' not found",
+      "element 'desc_0' not found",
+      "This feed contains no entries.");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeedNoLinks) {
   ASSERT_TRUE(test_server()->Start());
 
-  ASSERT_TRUE(LoadExtension(
-      test_data_dir_.AppendASCII("subscribe_page_action")));
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("subscribe_page_action"));
+  ASSERT_TRUE(extension);
+  std::string id = extension->id();
 
   // Valid feed but containing no links.
-  NavigateToFeedAndValidate(test_server(), kValidFeedNoLinks, browser(), true,
-                            "Feed for MyFeedTitle",
-                            "Title with no link",
-                            "Desc",
-                            "No error");
+  NavigateToFeedAndValidate(
+      test_server(), kValidFeedNoLinks, browser(), id, true,
+      "Feed for MyFeedTitle",
+      "Title with no link",
+      "Desc",
+      "No error");
 }
 
 // Tests that an error raised during an async function still fires
 // the callback, but sets chrome.extension.lastError.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, LastError) {
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("browsertest").AppendASCII("last_error")));
 
   // Get the ExtensionHost that is hosting our background page.
   ExtensionProcessManager* manager =
@@ skipping 111 matching lines @@
 
   // With no extensions, the plugin should not be loaded.
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), L"", L"testPluginWorks()", &result));
   EXPECT_FALSE(result);
 
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->set_show_extensions_prompts(false);
   const size_t size_before = service->extensions()->size();
-  ASSERT_TRUE(LoadExtension(extension_dir));
+  const Extension* extension = LoadExtension(extension_dir);
+  ASSERT_TRUE(extension);
   EXPECT_EQ(size_before + 1, service->extensions()->size());
   // Now the plugin should be in the cache, but we have to reload the page for
   // it to work.
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), L"", L"testPluginWorks()", &result));
   EXPECT_FALSE(result);
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(
             &browser()->GetSelectedTabContentsWrapper()->controller()));
     browser()->Reload(CURRENT_TAB);
     observer.Wait();
   }
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), L"", L"testPluginWorks()", &result));
   EXPECT_TRUE(result);
 
   EXPECT_EQ(size_before + 1, service->extensions()->size());
-  UnloadExtension(service->extensions()->at(size_before)->id());
+  UnloadExtension(extension->id());
   EXPECT_EQ(size_before, service->extensions()->size());
 
   // Now the plugin should be unloaded, and the page should be broken.
 
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), L"", L"testPluginWorks()", &result));
   EXPECT_FALSE(result);
 
   // If we reload the extension and page, it should work again.
 
@@ skipping 21 matching lines @@
 #endif
 
 // Tests that private extension plugins are only visible to the extension.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, MAYBE_PluginPrivate) {
   FilePath extension_dir =
       test_data_dir_.AppendASCII("uitest").AppendASCII("plugins_private");
 
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->set_show_extensions_prompts(false);
   const size_t size_before = service->extensions()->size();
-  ASSERT_TRUE(LoadExtension(extension_dir));
+  const Extension* extension = LoadExtension(extension_dir);
+  ASSERT_TRUE(extension);
   EXPECT_EQ(size_before + 1, service->extensions()->size());
 
   // Load the test page through the extension URL, and the plugin should work.
-  const Extension* extension = service->extensions()->back();
   ui_test_utils::NavigateToURL(browser(),
       extension->GetResourceURL("test.html"));
   TabContents* tab = browser()->GetSelectedTabContents();
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), L"", L"testPluginWorks()", &result));
   // We don't allow extension plugins to run on ChromeOS.
 #if defined(OS_CHROMEOS)
   EXPECT_FALSE(result);
 #else
@@ skipping 16 matching lines @@
     L"      null).snapshotItem(0);"
     L"  button.click();"
     L"})();";
 
 // Test that an extension with an options page makes an 'Options' button appear
 // on chrome://extensions, and that clicking the button opens a new tab with the
 // extension's options page.
 // Disabled.  See http://crbug.com/26948 for details.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, DISABLED_OptionsPage) {
   // Install an extension with an options page.
-  ASSERT_TRUE(InstallExtension(test_data_dir_.AppendASCII("options.crx"), 1));
+  const Extension* extension =
+      InstallExtension(test_data_dir_.AppendASCII("options.crx"), 1);
+  ASSERT_TRUE(extension);
   ExtensionService* service = browser()->profile()->GetExtensionService();
-  const ExtensionList* extensions = service->extensions();
-  ASSERT_EQ(1u, extensions->size());
-  const Extension* extension = extensions->at(0);
+  ASSERT_EQ(1u, service->extensions()->size());
 
   // Go to the Extension Settings page and click the Options button.
   ui_test_utils::NavigateToURL(
       browser(), GURL(std::string(chrome::kChromeUISettingsURL) +
                       chrome::kExtensionsSubPage));
   TabStripModel* tab_strip = browser()->tabstrip_model();
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScript(
       browser()->GetSelectedTabContents()->render_view_host(), L"",
       jscript_click_option_button));
 
   // If the options page hasn't already come up, wait for it.
   if (tab_strip->count() == 1) {
     ui_test_utils::WaitForNewTab(browser());
   }
   ASSERT_EQ(2, tab_strip->count());
 
   EXPECT_EQ(extension->GetResourceURL("options.html"),
             tab_strip->GetTabContentsAt(1)->tab_contents()->GetURL());
 }
 
 //==============================================================================
 // STOP! Please do not add any more random-ass tests here. Create new files for
 // your tests grouped by functionality. Also, you should strongly consider using
 // ExtensionAPITest if possible.
 //==============================================================================