Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/browser_process.h"
      6 #include "chrome/browser/extensions/extension_browsertest.h"
      7 #include "chrome/browser/extensions/extension_host.h"
      8 #include "chrome/browser/extensions/extension_process_manager.h"
      9 #include "chrome/browser/extensions/extension_service.h"
     10 #include "chrome/browser/extensions/extension_system.h"
     11 #include "chrome/browser/notifications/balloon.h"
     12 #include "chrome/browser/notifications/balloon_collection.h"
     13 #include "chrome/browser/notifications/balloon_host.h"
     14 #include "chrome/browser/notifications/balloon_notification_ui_manager.h"
     15 #include "chrome/browser/notifications/notification.h"
     16 #include "chrome/browser/notifications/notification_delegate.h"
     17 #include "chrome/browser/profiles/profile.h"
     18 #include "chrome/browser/ui/browser.h"
     19 #include "chrome/browser/ui/browser_commands.h"
     20 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     21 #include "chrome/test/base/ui_test_utils.h"
     22 #include "content/public/browser/navigation_controller.h"
     23 #include "content/public/browser/render_process_host.h"
     24 #include "content/public/browser/render_view_host.h"
     25 #include "content/public/browser/web_contents.h"
     26 #include "content/public/common/result_codes.h"
     27 #include "ui/message_center/message_center.h"
     28 #include "ui/message_center/message_center_switches.h"
     29 #include "ui/message_center/message_center_util.h"
     30 #include "ui/message_center/notification_list.h"
     31 
     32 using content::NavigationController;
     33 using content::WebContents;
     34 using extensions::Extension;
     35 
     36 // Tests are timing out waiting for extension to crash.
     37 // http://crbug.com/174705
     38 #if defined(OS_MACOSX) || defined(USE_AURA) || defined(OS_LINUX)
     39 #define MAYBE_ExtensionCrashRecoveryTest DISABLED_ExtensionCrashRecoveryTest
     40 #else
     41 #define MAYBE_ExtensionCrashRecoveryTest ExtensionCrashRecoveryTest
     42 #endif  // defined(OS_MACOSX) || defined(USE_AURA) || defined(OS_LINUX)
     43 
     44 class ExtensionCrashRecoveryTestBase : public ExtensionBrowserTest {
     45  protected:
     46   virtual void AcceptNotification(size_t index) = 0;
     47   virtual void CancelNotification(size_t index) = 0;
     48   virtual size_t CountBalloons() = 0;
     49 
     50   ExtensionService* GetExtensionService() {
     51     return browser()->profile()->GetExtensionService();
     52   }
     53 
     54   ExtensionProcessManager* GetExtensionProcessManager() {
     55     return extensions::ExtensionSystem::Get(browser()->profile())->
     56         process_manager();
     57   }
     58 
     59   void CrashExtension(std::string extension_id) {
     60     const Extension* extension =
     61         GetExtensionService()->GetExtensionById(extension_id, false);
     62     ASSERT_TRUE(extension);
     63     extensions::ExtensionHost* extension_host = GetExtensionProcessManager()->
     64         GetBackgroundHostForExtension(extension_id);
     65     ASSERT_TRUE(extension_host);
     66 
     67     base::KillProcess(extension_host->render_process_host()->GetHandle(),
     68                       content::RESULT_CODE_KILLED, false);
     69     ASSERT_TRUE(WaitForExtensionCrash(extension_id));
     70     ASSERT_FALSE(GetExtensionProcessManager()->
     71                  GetBackgroundHostForExtension(extension_id));
     72 
     73     // Wait for extension crash balloon to appear.
     74     base::MessageLoop::current()->RunUntilIdle();
     75   }
     76 
     77   void CheckExtensionConsistency(std::string extension_id) {
     78     const Extension* extension =
     79         GetExtensionService()->extensions()->GetByID(extension_id);
     80     ASSERT_TRUE(extension);
     81     extensions::ExtensionHost* extension_host = GetExtensionProcessManager()->
     82         GetBackgroundHostForExtension(extension_id);
     83     ASSERT_TRUE(extension_host);
     84     ExtensionProcessManager::ViewSet all_views =
     85         GetExtensionProcessManager()->GetAllViews();
     86     ExtensionProcessManager::ViewSet::const_iterator it =
     87         all_views.find(extension_host->host_contents()->GetRenderViewHost());
     88     ASSERT_FALSE(it == all_views.end());
     89     ASSERT_TRUE(extension_host->IsRenderViewLive());
     90     extensions::ProcessMap* process_map =
     91         browser()->profile()->GetExtensionService()->process_map();
     92     ASSERT_TRUE(process_map->Contains(
     93         extension_id,
     94         extension_host->render_view_host()->GetProcess()->GetID()));
     95   }
     96 
     97   void LoadTestExtension() {
     98     ExtensionBrowserTest::SetUpInProcessBrowserTestFixture();
     99     const Extension* extension = LoadExtension(
    100         test_data_dir_.AppendASCII("common").AppendASCII("background_page"));
    101     ASSERT_TRUE(extension);
    102     first_extension_id_ = extension->id();
    103     CheckExtensionConsistency(first_extension_id_);
    104   }
    105 
    106   void LoadSecondExtension() {
    107     const Extension* extension = LoadExtension(
    108         test_data_dir_.AppendASCII("install").AppendASCII("install"));
    109     ASSERT_TRUE(extension);
    110     second_extension_id_ = extension->id();
    111     CheckExtensionConsistency(second_extension_id_);
    112   }
    113 
    114   std::string first_extension_id_;
    115   std::string second_extension_id_;
    116 };
    117 
    118 class MAYBE_ExtensionCrashRecoveryTest
    119     : public ExtensionCrashRecoveryTestBase {
    120  protected:
    121   virtual void AcceptNotification(size_t index) OVERRIDE {
    122     if (message_center::IsRichNotificationEnabled()) {
    123       message_center::MessageCenter* message_center =
    124           message_center::MessageCenter::Get();
    125       ASSERT_GT(message_center->NotificationCount(), index);
    126       message_center::NotificationList::Notifications::reverse_iterator it =
    127           message_center->GetNotifications().rbegin();
    128       for (size_t i=0; i < index; ++i)
    129         it++;
    130       std::string id = (*it)->id();
    131       message_center->ClickOnNotification(id);
    132     } else {
    133       Balloon* balloon = GetNotificationDelegate(index);
    134       ASSERT_TRUE(balloon);
    135       balloon->OnClick();
    136     }
    137     WaitForExtensionLoad();
    138   }
    139 
    140   virtual void CancelNotification(size_t index) OVERRIDE {
    141     if (message_center::IsRichNotificationEnabled()) {
    142       message_center::MessageCenter* message_center =
    143           message_center::MessageCenter::Get();
    144       ASSERT_GT(message_center->NotificationCount(), index);
    145       message_center::NotificationList::Notifications::reverse_iterator it =
    146           message_center->GetNotifications().rbegin();
    147       for (size_t i=0; i < index; i++) { it++; }
    148       ASSERT_TRUE(g_browser_process->notification_ui_manager()->
    149           CancelById((*it)->id()));
    150     } else {
    151       Balloon* balloon = GetNotificationDelegate(index);
    152       ASSERT_TRUE(balloon);
    153       std::string id = balloon->notification().notification_id();
    154       ASSERT_TRUE(g_browser_process->notification_ui_manager()->CancelById(id));
    155     }
    156   }
    157 
    158   virtual size_t CountBalloons() OVERRIDE {
    159     if (message_center::IsRichNotificationEnabled())
    160       return message_center::MessageCenter::Get()->NotificationCount();
    161 
    162     return BalloonNotificationUIManager::GetInstanceForTesting()->
    163         balloon_collection()->GetActiveBalloons().size();
    164   }
    165 
    166 private:
    167      Balloon* GetNotificationDelegate(size_t index) {
    168        BalloonNotificationUIManager* manager =
    169            BalloonNotificationUIManager::GetInstanceForTesting();
    170        BalloonCollection::Balloons balloons =
    171            manager->balloon_collection()->GetActiveBalloons();
    172        return index < balloons.size() ? balloons.at(index) : NULL;
    173      }
    174 };
    175 
    176 // Flaky: http://crbug.com/242167.
    177 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest, DISABLED_Basic) {
    178   const size_t size_before = GetExtensionService()->extensions()->size();
    179   const size_t crash_size_before =
    180       GetExtensionService()->terminated_extensions()->size();
    181   LoadTestExtension();
    182   CrashExtension(first_extension_id_);
    183   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    184   ASSERT_EQ(crash_size_before + 1,
    185             GetExtensionService()->terminated_extensions()->size());
    186   ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    187 
    188   SCOPED_TRACE("after clicking the balloon");
    189   CheckExtensionConsistency(first_extension_id_);
    190   ASSERT_EQ(crash_size_before,
    191             GetExtensionService()->terminated_extensions()->size());
    192 }
    193 
    194 // Flaky, http://crbug.com/241191.
    195 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    196                        DISABLED_CloseAndReload) {
    197   const size_t size_before = GetExtensionService()->extensions()->size();
    198   const size_t crash_size_before =
    199       GetExtensionService()->terminated_extensions()->size();
    200   LoadTestExtension();
    201   CrashExtension(first_extension_id_);
    202 
    203   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    204   ASSERT_EQ(crash_size_before + 1,
    205             GetExtensionService()->terminated_extensions()->size());
    206 
    207   ASSERT_NO_FATAL_FAILURE(CancelNotification(0));
    208   ReloadExtension(first_extension_id_);
    209 
    210   SCOPED_TRACE("after reloading");
    211   CheckExtensionConsistency(first_extension_id_);
    212   ASSERT_EQ(crash_size_before,
    213             GetExtensionService()->terminated_extensions()->size());
    214 }
    215 
    216 // Test is timing out on Windows http://crbug.com/174705.
    217 #if defined(OS_WIN)
    218 #define MAYBE_ReloadIndependently DISABLED_ReloadIndependently
    219 #else
    220 #define MAYBE_ReloadIndependently ReloadIndependently
    221 #endif  // defined(OS_WIN)
    222 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    223                        MAYBE_ReloadIndependently) {
    224   const size_t size_before = GetExtensionService()->extensions()->size();
    225   LoadTestExtension();
    226   CrashExtension(first_extension_id_);
    227   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    228 
    229   ReloadExtension(first_extension_id_);
    230 
    231   SCOPED_TRACE("after reloading");
    232   CheckExtensionConsistency(first_extension_id_);
    233 
    234   WebContents* current_tab =
    235       browser()->tab_strip_model()->GetActiveWebContents();
    236   ASSERT_TRUE(current_tab);
    237 
    238   // The balloon should automatically hide after the extension is successfully
    239   // reloaded.
    240   ASSERT_EQ(0U, CountBalloons());
    241 }
    242 
    243 // Test is timing out on Windows http://crbug.com/174705.
    244 #if defined(OS_WIN)
    245 #define MAYBE_ReloadIndependentlyChangeTabs DISABLED_ReloadIndependentlyChangeTabs
    246 #else
    247 #define MAYBE_ReloadIndependentlyChangeTabs ReloadIndependentlyChangeTabs
    248 #endif  // defined(OS_WIN)
    249 
    250 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    251                        MAYBE_ReloadIndependentlyChangeTabs) {
    252   const size_t size_before = GetExtensionService()->extensions()->size();
    253   LoadTestExtension();
    254   CrashExtension(first_extension_id_);
    255   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    256 
    257   WebContents* original_tab =
    258       browser()->tab_strip_model()->GetActiveWebContents();
    259   ASSERT_TRUE(original_tab);
    260   ASSERT_EQ(1U, CountBalloons());
    261 
    262   // Open a new tab, but the balloon will still be there.
    263   chrome::NewTab(browser());
    264   WebContents* new_current_tab =
    265       browser()->tab_strip_model()->GetActiveWebContents();
    266   ASSERT_TRUE(new_current_tab);
    267   ASSERT_NE(new_current_tab, original_tab);
    268   ASSERT_EQ(1U, CountBalloons());
    269 
    270   ReloadExtension(first_extension_id_);
    271 
    272   SCOPED_TRACE("after reloading");
    273   CheckExtensionConsistency(first_extension_id_);
    274 
    275   // The balloon should automatically hide after the extension is successfully
    276   // reloaded.
    277   ASSERT_EQ(0U, CountBalloons());
    278 }
    279 
    280 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    281                        DISABLED_ReloadIndependentlyNavigatePage) {
    282   const size_t size_before = GetExtensionService()->extensions()->size();
    283   LoadTestExtension();
    284   CrashExtension(first_extension_id_);
    285   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    286 
    287   WebContents* current_tab =
    288       browser()->tab_strip_model()->GetActiveWebContents();
    289   ASSERT_TRUE(current_tab);
    290   ASSERT_EQ(1U, CountBalloons());
    291 
    292   // Navigate to another page.
    293   ui_test_utils::NavigateToURL(
    294       browser(), ui_test_utils::GetTestUrl(
    295                      base::FilePath(base::FilePath::kCurrentDirectory),
    296                      base::FilePath(FILE_PATH_LITERAL("title1.html"))));
    297   ASSERT_EQ(1U, CountBalloons());
    298 
    299   ReloadExtension(first_extension_id_);
    300 
    301   SCOPED_TRACE("after reloading");
    302   CheckExtensionConsistency(first_extension_id_);
    303 
    304   // The balloon should automatically hide after the extension is successfully
    305   // reloaded.
    306   ASSERT_EQ(0U, CountBalloons());
    307 }
    308 
    309 // Make sure that when we don't do anything about the crashed extension
    310 // and close the browser, it doesn't crash. The browser is closed implicitly
    311 // at the end of each browser test.
    312 //
    313 // http://crbug.com/84719
    314 #if defined(OS_LINUX)
    315 #define MAYBE_ShutdownWhileCrashed DISABLED_ShutdownWhileCrashed
    316 #else
    317 #define MAYBE_ShutdownWhileCrashed ShutdownWhileCrashed
    318 #endif  // defined(OS_LINUX)
    319 
    320 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    321                        MAYBE_ShutdownWhileCrashed) {
    322   const size_t size_before = GetExtensionService()->extensions()->size();
    323   LoadTestExtension();
    324   CrashExtension(first_extension_id_);
    325   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    326 }
    327 
    328 // Flaky, http://crbug.com/241245.
    329 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    330                        DISABLED_TwoExtensionsCrashFirst) {
    331   const size_t size_before = GetExtensionService()->extensions()->size();
    332   LoadTestExtension();
    333   LoadSecondExtension();
    334   CrashExtension(first_extension_id_);
    335   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    336   ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    337 
    338   SCOPED_TRACE("after clicking the balloon");
    339   CheckExtensionConsistency(first_extension_id_);
    340   CheckExtensionConsistency(second_extension_id_);
    341 }
    342 
    343 // Flaky: http://crbug.com/242196
    344 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    345                        DISABLED_TwoExtensionsCrashSecond) {
    346   const size_t size_before = GetExtensionService()->extensions()->size();
    347   LoadTestExtension();
    348   LoadSecondExtension();
    349   CrashExtension(second_extension_id_);
    350   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    351   ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    352 
    353   SCOPED_TRACE("after clicking the balloon");
    354   CheckExtensionConsistency(first_extension_id_);
    355   CheckExtensionConsistency(second_extension_id_);
    356 }
    357 
    358 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    359                        TwoExtensionsCrashBothAtOnce) {
    360   const size_t size_before = GetExtensionService()->extensions()->size();
    361   const size_t crash_size_before =
    362       GetExtensionService()->terminated_extensions()->size();
    363   LoadTestExtension();
    364   LoadSecondExtension();
    365   CrashExtension(first_extension_id_);
    366   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    367   ASSERT_EQ(crash_size_before + 1,
    368             GetExtensionService()->terminated_extensions()->size());
    369   CrashExtension(second_extension_id_);
    370   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    371   ASSERT_EQ(crash_size_before + 2,
    372             GetExtensionService()->terminated_extensions()->size());
    373 
    374   {
    375     SCOPED_TRACE("first balloon");
    376     ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    377     CheckExtensionConsistency(first_extension_id_);
    378   }
    379 
    380   {
    381     SCOPED_TRACE("second balloon");
    382     ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    383     CheckExtensionConsistency(first_extension_id_);
    384     CheckExtensionConsistency(second_extension_id_);
    385   }
    386 }
    387 
    388 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    389                        TwoExtensionsOneByOne) {
    390   const size_t size_before = GetExtensionService()->extensions()->size();
    391   LoadTestExtension();
    392   CrashExtension(first_extension_id_);
    393   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    394   LoadSecondExtension();
    395   CrashExtension(second_extension_id_);
    396   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    397 
    398   {
    399     SCOPED_TRACE("first balloon");
    400     ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    401     CheckExtensionConsistency(first_extension_id_);
    402   }
    403 
    404   {
    405     SCOPED_TRACE("second balloon");
    406     ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    407     CheckExtensionConsistency(first_extension_id_);
    408     CheckExtensionConsistency(second_extension_id_);
    409   }
    410 }
    411 
    412 // http://crbug.com/84719
    413 #if defined(OS_LINUX)
    414 #define MAYBE_TwoExtensionsShutdownWhileCrashed \
    415     DISABLED_TwoExtensionsShutdownWhileCrashed
    416 #else
    417 #define MAYBE_TwoExtensionsShutdownWhileCrashed \
    418     TwoExtensionsShutdownWhileCrashed
    419 #endif  // defined(OS_LINUX)
    420 
    421 // Make sure that when we don't do anything about the crashed extensions
    422 // and close the browser, it doesn't crash. The browser is closed implicitly
    423 // at the end of each browser test.
    424 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    425                        MAYBE_TwoExtensionsShutdownWhileCrashed) {
    426   const size_t size_before = GetExtensionService()->extensions()->size();
    427   LoadTestExtension();
    428   CrashExtension(first_extension_id_);
    429   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    430   LoadSecondExtension();
    431   CrashExtension(second_extension_id_);
    432   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    433 }
    434 
    435 // Flaky, http://crbug.com/241573.
    436 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    437                        DISABLED_TwoExtensionsIgnoreFirst) {
    438   const size_t size_before = GetExtensionService()->extensions()->size();
    439   LoadTestExtension();
    440   LoadSecondExtension();
    441   CrashExtension(first_extension_id_);
    442   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    443   CrashExtension(second_extension_id_);
    444   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    445 
    446   // Accept notification 1 before canceling notification 0.
    447   // Otherwise, on Linux and Windows, there is a race here, in which
    448   // canceled notifications do not immediately go away.
    449   ASSERT_NO_FATAL_FAILURE(AcceptNotification(1));
    450   ASSERT_NO_FATAL_FAILURE(CancelNotification(0));
    451 
    452   SCOPED_TRACE("balloons done");
    453   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    454   CheckExtensionConsistency(second_extension_id_);
    455 }
    456 
    457 // Flaky, http://crbug.com/241164.
    458 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    459                        DISABLED_TwoExtensionsReloadIndependently) {
    460   const size_t size_before = GetExtensionService()->extensions()->size();
    461   LoadTestExtension();
    462   LoadSecondExtension();
    463   CrashExtension(first_extension_id_);
    464   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    465   CrashExtension(second_extension_id_);
    466   ASSERT_EQ(size_before, GetExtensionService()->extensions()->size());
    467 
    468   {
    469     SCOPED_TRACE("first: reload");
    470     WebContents* current_tab =
    471         browser()->tab_strip_model()->GetActiveWebContents();
    472     ASSERT_TRUE(current_tab);
    473     // At the beginning we should have one balloon displayed for each extension.
    474     ASSERT_EQ(2U, CountBalloons());
    475     ReloadExtension(first_extension_id_);
    476     // One of the balloons should hide after the extension is reloaded.
    477     ASSERT_EQ(1U, CountBalloons());
    478     CheckExtensionConsistency(first_extension_id_);
    479   }
    480 
    481   {
    482     SCOPED_TRACE("second: balloon");
    483     ASSERT_NO_FATAL_FAILURE(AcceptNotification(0));
    484     CheckExtensionConsistency(first_extension_id_);
    485     CheckExtensionConsistency(second_extension_id_);
    486   }
    487 }
    488 
    489 // http://crbug.com/243648
    490 #if defined(OS_WIN)
    491 #define MAYBE_CrashAndUninstall DISABLED_CrashAndUninstall
    492 #else
    493 #define MAYBE_CrashAndUninstall CrashAndUninstall
    494 #endif
    495 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    496                        MAYBE_CrashAndUninstall) {
    497   const size_t size_before = GetExtensionService()->extensions()->size();
    498   const size_t crash_size_before =
    499       GetExtensionService()->terminated_extensions()->size();
    500   LoadTestExtension();
    501   LoadSecondExtension();
    502   CrashExtension(first_extension_id_);
    503   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    504   ASSERT_EQ(crash_size_before + 1,
    505             GetExtensionService()->terminated_extensions()->size());
    506 
    507   ASSERT_EQ(1U, CountBalloons());
    508   UninstallExtension(first_extension_id_);
    509   base::MessageLoop::current()->RunUntilIdle();
    510 
    511   SCOPED_TRACE("after uninstalling");
    512   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    513   ASSERT_EQ(crash_size_before,
    514             GetExtensionService()->terminated_extensions()->size());
    515   ASSERT_EQ(0U, CountBalloons());
    516 }
    517 
    518 // http://crbug.com/84719
    519 #if defined(OS_LINUX)
    520 #define MAYBE_CrashAndUnloadAll DISABLED_CrashAndUnloadAll
    521 #else
    522 #define MAYBE_CrashAndUnloadAll CrashAndUnloadAll
    523 #endif  // defined(OS_LINUX)
    524 
    525 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    526                        MAYBE_CrashAndUnloadAll) {
    527   const size_t size_before = GetExtensionService()->extensions()->size();
    528   const size_t crash_size_before =
    529       GetExtensionService()->terminated_extensions()->size();
    530   LoadTestExtension();
    531   LoadSecondExtension();
    532   CrashExtension(first_extension_id_);
    533   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    534   ASSERT_EQ(crash_size_before + 1,
    535             GetExtensionService()->terminated_extensions()->size());
    536 
    537   GetExtensionService()->UnloadAllExtensions();
    538   ASSERT_EQ(crash_size_before,
    539             GetExtensionService()->terminated_extensions()->size());
    540 }
    541 
    542 // Fails a DCHECK on Aura and Linux: http://crbug.com/169622
    543 // Failing on Windows: http://crbug.com/232340
    544 #if defined(USE_AURA) || defined(OS_WIN) || defined(OS_LINUX)
    545 #define MAYBE_ReloadTabsWithBackgroundPage DISABLED_ReloadTabsWithBackgroundPage
    546 #else
    547 #define MAYBE_ReloadTabsWithBackgroundPage ReloadTabsWithBackgroundPage
    548 #endif
    549 
    550 // Test that when an extension with a background page that has a tab open
    551 // crashes, the tab stays open, and reloading it reloads the extension.
    552 // Regression test for issue 71629.
    553 IN_PROC_BROWSER_TEST_F(MAYBE_ExtensionCrashRecoveryTest,
    554                        MAYBE_ReloadTabsWithBackgroundPage) {
    555   TabStripModel* tab_strip = browser()->tab_strip_model();
    556   const size_t size_before = GetExtensionService()->extensions()->size();
    557   const size_t crash_size_before =
    558       GetExtensionService()->terminated_extensions()->size();
    559   LoadTestExtension();
    560 
    561   // Open a tab extension.
    562   chrome::NewTab(browser());
    563   ui_test_utils::NavigateToURL(
    564       browser(),
    565       GURL("chrome-extension://" + first_extension_id_ + "/background.html"));
    566 
    567   const int tabs_before = tab_strip->count();
    568   CrashExtension(first_extension_id_);
    569 
    570   // Tab should still be open, and extension should be crashed.
    571   EXPECT_EQ(tabs_before, tab_strip->count());
    572   EXPECT_EQ(size_before, GetExtensionService()->extensions()->size());
    573   EXPECT_EQ(crash_size_before + 1,
    574             GetExtensionService()->terminated_extensions()->size());
    575 
    576   {
    577     content::WindowedNotificationObserver observer(
    578         content::NOTIFICATION_LOAD_STOP,
    579         content::Source<NavigationController>(
    580             &browser()->tab_strip_model()->GetActiveWebContents()->
    581                 GetController()));
    582     chrome::Reload(browser(), CURRENT_TAB);
    583     observer.Wait();
    584   }
    585   // Extension should now be loaded.
    586   SCOPED_TRACE("after reloading the tab");
    587   CheckExtensionConsistency(first_extension_id_);
    588   ASSERT_EQ(size_before + 1, GetExtensionService()->extensions()->size());
    589   ASSERT_EQ(0U, CountBalloons());
    590 }
    591