chrome/browser/extensions/app_background_page_apitest.cc

   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 "base/location.h"
   6 #include "base/path_service.h"
   7 #include "base/single_thread_task_runner.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "chrome/browser/background/background_contents_service.h"
  12 #include "chrome/browser/background/background_contents_service_factory.h"
  13 #include "chrome/browser/background/background_mode_manager.h"
  14 #include "chrome/browser/browser_process.h"
  15 #include "chrome/browser/extensions/extension_apitest.h"
  16 #include "chrome/browser/extensions/extension_service.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/browser/ui/browser.h"
  19 #include "chrome/browser/ui/browser_dialogs.h"
  20 #include "chrome/browser/ui/browser_window.h"
  21 #include "chrome/browser/ui/extensions/application_launch.h"
  22 #include "chrome/common/chrome_paths.h"
  23 #include "chrome/common/chrome_switches.h"
  24 #include "content/public/browser/notification_service.h"
  25 #include "content/public/test/test_notification_tracker.h"
  26 #include "content/public/test/test_utils.h"
  27 #include "extensions/browser/process_manager.h"
  28 #include "extensions/common/extension.h"
  29 #include "extensions/common/switches.h"
  30 #include "extensions/test/extension_test_message_listener.h"
  31 #include "net/dns/mock_host_resolver.h"
  32 #include "net/test/embedded_test_server/embedded_test_server.h"
  33
  34 #if !defined(DISABLE_NACL)
  35 #include "components/nacl/browser/nacl_process_host.h"
  36 #endif
  37
  38 #if defined(OS_MACOSX)
  39 #include "base/mac/scoped_nsautorelease_pool.h"
  40 #endif
  41
  42 using base::ASCIIToUTF16;
  43 using extensions::Extension;
  44
  45 class AppBackgroundPageApiTest : public ExtensionApiTest {
  46  public:
  47   void SetUpCommandLine(base::CommandLine* command_line) override {
  48     ExtensionApiTest::SetUpCommandLine(command_line);
  49     command_line->AppendSwitch(switches::kDisablePopupBlocking);
  50     command_line->AppendSwitch(extensions::switches::kAllowHTTPBackgroundPage);
  51   }
  52
  53   bool CreateApp(const std::string& app_manifest,
  54                  base::FilePath* app_dir) {
  55     if (!app_dir_.CreateUniqueTempDir()) {
  56       LOG(ERROR) << "Unable to create a temporary directory.";
  57       return false;
  58     }
  59     base::FilePath manifest_path = app_dir_.path().AppendASCII("manifest.json");
  60     int bytes_written = base::WriteFile(manifest_path,
  61                                         app_manifest.data(),
  62                                         app_manifest.size());
  63     if (bytes_written != static_cast<int>(app_manifest.size())) {
  64       LOG(ERROR) << "Unable to write complete manifest to file. Return code="
  65                  << bytes_written;
  66       return false;
  67     }
  68     *app_dir = app_dir_.path();
  69     return true;
  70   }
  71
  72   bool WaitForBackgroundMode(bool expected_background_mode) {
  73 #if defined(OS_CHROMEOS)
  74     // BackgroundMode is not supported on chromeos, so we should test the
  75     // behavior of BackgroundContents, but not the background mode state itself.
  76     return true;
  77 #else
  78     BackgroundModeManager* manager =
  79         g_browser_process->background_mode_manager();
  80     // If background mode is disabled on this platform (e.g. cros), then skip
  81     // this check.
  82     if (!manager || !manager->IsBackgroundModePrefEnabled()) {
  83       DLOG(WARNING) << "Skipping check - background mode disabled";
  84       return true;
  85     }
  86     if (manager->IsBackgroundModeActive() == expected_background_mode)
  87       return true;
  88
  89     // We are not currently in the expected state - wait for the state to
  90     // change.
  91     content::WindowedNotificationObserver watcher(
  92         chrome::NOTIFICATION_BACKGROUND_MODE_CHANGED,
  93         content::NotificationService::AllSources());
  94     watcher.Wait();
  95     return manager->IsBackgroundModeActive() == expected_background_mode;
  96 #endif
  97   }
  98
  99   void UnloadExtensionViaTask(const std::string& id) {
 100     base::ThreadTaskRunnerHandle::Get()->PostTask(
 101         FROM_HERE,
 102         base::Bind(&AppBackgroundPageApiTest::UnloadExtension, this, id));
 103   }
 104
 105  private:
 106   base::ScopedTempDir app_dir_;
 107 };
 108
 109 namespace {
 110
 111 // Fixture to assist in testing v2 app background pages containing
 112 // Native Client embeds.
 113 class AppBackgroundPageNaClTest : public AppBackgroundPageApiTest {
 114  public:
 115   AppBackgroundPageNaClTest()
 116       : extension_(NULL) {}
 117   ~AppBackgroundPageNaClTest() override {}
 118
 119   void SetUpOnMainThread() override {
 120     AppBackgroundPageApiTest::SetUpOnMainThread();
 121 #if !defined(DISABLE_NACL)
 122     nacl::NaClProcessHost::SetPpapiKeepAliveThrottleForTesting(50);
 123 #endif
 124     extensions::ProcessManager::SetEventPageIdleTimeForTesting(1000);
 125     extensions::ProcessManager::SetEventPageSuspendingTimeForTesting(1000);
 126   }
 127
 128   const Extension* extension() { return extension_; }
 129
 130  protected:
 131   void LaunchTestingApp() {
 132     base::FilePath app_dir;
 133     PathService::Get(chrome::DIR_GEN_TEST_DATA, &app_dir);
 134     app_dir = app_dir.AppendASCII(
 135         "ppapi/tests/extensions/background_keepalive/newlib");
 136     extension_ = LoadExtension(app_dir);
 137     ASSERT_TRUE(extension_);
 138   }
 139
 140  private:
 141   const Extension* extension_;
 142 };
 143
 144 // Produces an extensions::ProcessManager::ImpulseCallbackForTesting callback
 145 // that will match a specified goal and can be waited on.
 146 class ImpulseCallbackCounter {
 147  public:
 148   explicit ImpulseCallbackCounter(extensions::ProcessManager* manager,
 149                                   const std::string& extension_id)
 150       : observed_(0),
 151         goal_(0),
 152         manager_(manager),
 153         extension_id_(extension_id) {
 154   }
 155
 156   extensions::ProcessManager::ImpulseCallbackForTesting
 157       SetGoalAndGetCallback(int goal) {
 158     observed_ = 0;
 159     goal_ = goal;
 160     message_loop_runner_ = new content::MessageLoopRunner();
 161     return base::Bind(&ImpulseCallbackCounter::ImpulseCallback,
 162                       base::Unretained(this),
 163                       message_loop_runner_->QuitClosure(),
 164                       extension_id_);
 165   }
 166
 167   void Wait() {
 168     message_loop_runner_->Run();
 169   }
 170  private:
 171   void ImpulseCallback(
 172       const base::Closure& quit_callback,
 173       const std::string& extension_id_from_test,
 174       const std::string& extension_id_from_manager) {
 175     if (extension_id_from_test == extension_id_from_manager) {
 176       if (++observed_ >= goal_) {
 177         // Clear callback to free reference to message loop.
 178         manager_->SetKeepaliveImpulseCallbackForTesting(
 179             extensions::ProcessManager::ImpulseCallbackForTesting());
 180         manager_->SetKeepaliveImpulseDecrementCallbackForTesting(
 181             extensions::ProcessManager::ImpulseCallbackForTesting());
 182         quit_callback.Run();
 183       }
 184     }
 185   }
 186
 187   int observed_;
 188   int goal_;
 189   extensions::ProcessManager* manager_;
 190   const std::string extension_id_;
 191   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 192 };
 193
 194 }  // namespace
 195
 196 // Disable on Mac only.  http://crbug.com/95139
 197 #if defined(OS_MACOSX)
 198 #define MAYBE_Basic DISABLED_Basic
 199 #else
 200 #define MAYBE_Basic Basic
 201 #endif
 202
 203 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, MAYBE_Basic) {
 204   host_resolver()->AddRule("a.com", "127.0.0.1");
 205   ASSERT_TRUE(StartEmbeddedTestServer());
 206
 207   std::string app_manifest = base::StringPrintf(
 208       "{"
 209       "  \"name\": \"App\","
 210       "  \"version\": \"0.1\","
 211       "  \"manifest_version\": 2,"
 212       "  \"app\": {"
 213       "    \"urls\": ["
 214       "      \"http://a.com/\""
 215       "    ],"
 216       "    \"launch\": {"
 217       "      \"web_url\": \"http://a.com:%u/\""
 218       "    }"
 219       "  },"
 220       "  \"permissions\": [\"background\"]"
 221       "}",
 222       embedded_test_server()->port());
 223
 224   base::FilePath app_dir;
 225   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 226   ASSERT_TRUE(LoadExtension(app_dir));
 227   // Background mode should not be active until a background page is created.
 228   ASSERT_TRUE(WaitForBackgroundMode(false));
 229   ASSERT_TRUE(RunExtensionTest("app_background_page/basic")) << message_;
 230   // The test closes the background contents, so we should fall back to no
 231   // background mode at the end.
 232   ASSERT_TRUE(WaitForBackgroundMode(false));
 233 }
 234
 235 // Crashy, http://crbug.com/69215.
 236 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, DISABLED_LacksPermission) {
 237   host_resolver()->AddRule("a.com", "127.0.0.1");
 238   ASSERT_TRUE(StartEmbeddedTestServer());
 239
 240   std::string app_manifest = base::StringPrintf(
 241       "{"
 242       "  \"name\": \"App\","
 243       "  \"version\": \"0.1\","
 244       "  \"manifest_version\": 2,"
 245       "  \"app\": {"
 246       "    \"urls\": ["
 247       "      \"http://a.com/\""
 248       "    ],"
 249       "    \"launch\": {"
 250       "      \"web_url\": \"http://a.com:%u/\""
 251       "    }"
 252       "  }"
 253       "}",
 254       embedded_test_server()->port());
 255
 256   base::FilePath app_dir;
 257   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 258   ASSERT_TRUE(LoadExtension(app_dir));
 259   ASSERT_TRUE(RunExtensionTest("app_background_page/lacks_permission"))
 260       << message_;
 261   ASSERT_TRUE(WaitForBackgroundMode(false));
 262 }
 263
 264 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, ManifestBackgroundPage) {
 265   host_resolver()->AddRule("a.com", "127.0.0.1");
 266   ASSERT_TRUE(StartEmbeddedTestServer());
 267
 268   std::string app_manifest = base::StringPrintf(
 269       "{"
 270       "  \"name\": \"App\","
 271       "  \"version\": \"0.1\","
 272       "  \"manifest_version\": 2,"
 273       "  \"app\": {"
 274       "    \"urls\": ["
 275       "      \"http://a.com/\""
 276       "    ],"
 277       "    \"launch\": {"
 278       "      \"web_url\": \"http://a.com:%u/\""
 279       "    }"
 280       "  },"
 281       "  \"permissions\": [\"background\"],"
 282       "  \"background\": {"
 283       "    \"page\": \"http://a.com:%u/test.html\""
 284       "  }"
 285       "}",
 286       embedded_test_server()->port(),
 287       embedded_test_server()->port());
 288
 289   base::FilePath app_dir;
 290   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 291   // Background mode should not be active now because no background app was
 292   // loaded.
 293   ASSERT_TRUE(LoadExtension(app_dir));
 294   // Background mode be active now because a background page was created when
 295   // the app was loaded.
 296   ASSERT_TRUE(WaitForBackgroundMode(true));
 297
 298   const Extension* extension = GetSingleLoadedExtension();
 299   ASSERT_TRUE(
 300       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 301           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 302   UnloadExtension(extension->id());
 303 }
 304
 305 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, NoJsBackgroundPage) {
 306   // Keep the task manager up through this test to verify that a crash doesn't
 307   // happen when window.open creates a background page that switches
 308   // RenderViewHosts. See http://crbug.com/165138.
 309   chrome::ShowTaskManager(browser());
 310
 311   // Make sure that no BackgroundContentses get deleted (a signal that repeated
 312   // window.open calls recreate instances, instead of being no-ops).
 313   content::TestNotificationTracker background_deleted_tracker;
 314   background_deleted_tracker.ListenFor(
 315       chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED,
 316       content::Source<Profile>(browser()->profile()));
 317
 318   host_resolver()->AddRule("a.com", "127.0.0.1");
 319   ASSERT_TRUE(StartEmbeddedTestServer());
 320
 321   std::string app_manifest = base::StringPrintf(
 322       "{"
 323       "  \"name\": \"App\","
 324       "  \"version\": \"0.1\","
 325       "  \"manifest_version\": 2,"
 326       "  \"app\": {"
 327       "    \"urls\": ["
 328       "      \"http://a.com/\""
 329       "    ],"
 330       "    \"launch\": {"
 331       "      \"web_url\": \"http://a.com:%u/test.html\""
 332       "    }"
 333       "  },"
 334       "  \"permissions\": [\"background\"],"
 335       "  \"background\": {"
 336       "    \"allow_js_access\": false"
 337       "  }"
 338       "}",
 339       embedded_test_server()->port());
 340
 341   base::FilePath app_dir;
 342   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 343   ASSERT_TRUE(LoadExtension(app_dir));
 344
 345   // There isn't a background page loaded initially.
 346   const Extension* extension = GetSingleLoadedExtension();
 347   ASSERT_FALSE(
 348       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 349           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 350   // The test makes sure that window.open returns null.
 351   ASSERT_TRUE(RunExtensionTest("app_background_page/no_js")) << message_;
 352   // And after it runs there should be a background page.
 353   ASSERT_TRUE(
 354       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 355           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 356
 357   EXPECT_EQ(0u, background_deleted_tracker.size());
 358   UnloadExtension(extension->id());
 359 }
 360
 361 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, NoJsManifestBackgroundPage) {
 362   host_resolver()->AddRule("a.com", "127.0.0.1");
 363   ASSERT_TRUE(StartEmbeddedTestServer());
 364
 365   std::string app_manifest = base::StringPrintf(
 366       "{"
 367       "  \"name\": \"App\","
 368       "  \"version\": \"0.1\","
 369       "  \"manifest_version\": 2,"
 370       "  \"app\": {"
 371       "    \"urls\": ["
 372       "      \"http://a.com/\""
 373       "    ],"
 374       "    \"launch\": {"
 375       "      \"web_url\": \"http://a.com:%u/\""
 376       "    }"
 377       "  },"
 378       "  \"permissions\": [\"background\"],"
 379       "  \"background\": {"
 380       "    \"page\": \"http://a.com:%u/bg.html\","
 381       "    \"allow_js_access\": false"
 382       "  }"
 383       "}",
 384       embedded_test_server()->port(),
 385       embedded_test_server()->port());
 386
 387   base::FilePath app_dir;
 388   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 389   ASSERT_TRUE(LoadExtension(app_dir));
 390
 391   // The background page should load, but window.open should return null.
 392   const Extension* extension = GetSingleLoadedExtension();
 393   ASSERT_TRUE(
 394       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 395           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 396   ASSERT_TRUE(RunExtensionTest("app_background_page/no_js_manifest")) <<
 397       message_;
 398   UnloadExtension(extension->id());
 399 }
 400
 401 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, OpenTwoBackgroundPages) {
 402   host_resolver()->AddRule("a.com", "127.0.0.1");
 403   ASSERT_TRUE(StartEmbeddedTestServer());
 404
 405   std::string app_manifest = base::StringPrintf(
 406       "{"
 407       "  \"name\": \"App\","
 408       "  \"version\": \"0.1\","
 409       "  \"manifest_version\": 2,"
 410       "  \"app\": {"
 411       "    \"urls\": ["
 412       "      \"http://a.com/\""
 413       "    ],"
 414       "    \"launch\": {"
 415       "      \"web_url\": \"http://a.com:%u/\""
 416       "    }"
 417       "  },"
 418       "  \"permissions\": [\"background\"]"
 419       "}",
 420       embedded_test_server()->port());
 421
 422   base::FilePath app_dir;
 423   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 424   ASSERT_TRUE(LoadExtension(app_dir));
 425   const Extension* extension = GetSingleLoadedExtension();
 426   ASSERT_TRUE(RunExtensionTest("app_background_page/two_pages")) << message_;
 427   UnloadExtension(extension->id());
 428 }
 429
 430 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, OpenTwoPagesWithManifest) {
 431   host_resolver()->AddRule("a.com", "127.0.0.1");
 432   ASSERT_TRUE(StartEmbeddedTestServer());
 433
 434   std::string app_manifest = base::StringPrintf(
 435       "{"
 436       "  \"name\": \"App\","
 437       "  \"version\": \"0.1\","
 438       "  \"manifest_version\": 2,"
 439       "  \"app\": {"
 440       "    \"urls\": ["
 441       "      \"http://a.com/\""
 442       "    ],"
 443       "    \"launch\": {"
 444       "      \"web_url\": \"http://a.com:%u/\""
 445       "    }"
 446       "  },"
 447       "  \"background\": {"
 448       "    \"page\": \"http://a.com:%u/bg.html\""
 449       "  },"
 450       "  \"permissions\": [\"background\"]"
 451       "}",
 452       embedded_test_server()->port(),
 453       embedded_test_server()->port());
 454
 455   base::FilePath app_dir;
 456   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 457   ASSERT_TRUE(LoadExtension(app_dir));
 458   const Extension* extension = GetSingleLoadedExtension();
 459   ASSERT_TRUE(RunExtensionTest("app_background_page/two_with_manifest")) <<
 460       message_;
 461   UnloadExtension(extension->id());
 462 }
 463
 464 // Times out occasionally -- see crbug.com/108493
 465 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, DISABLED_OpenPopupFromBGPage) {
 466   host_resolver()->AddRule("a.com", "127.0.0.1");
 467   ASSERT_TRUE(StartEmbeddedTestServer());
 468
 469   std::string app_manifest = base::StringPrintf(
 470       "{"
 471       "  \"name\": \"App\","
 472       "  \"version\": \"0.1\","
 473       "  \"manifest_version\": 2,"
 474       "  \"app\": {"
 475       "    \"urls\": ["
 476       "      \"http://a.com/\""
 477       "    ],"
 478       "    \"launch\": {"
 479       "      \"web_url\": \"http://a.com:%u/\""
 480       "    }"
 481       "  },"
 482       "  \"background\": { \"page\": \"http://a.com:%u/extensions/api_test/"
 483       "app_background_page/bg_open/bg_open_bg.html\" },"
 484       "  \"permissions\": [\"background\"]"
 485       "}",
 486       embedded_test_server()->port(),
 487       embedded_test_server()->port());
 488
 489   base::FilePath app_dir;
 490   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 491   ASSERT_TRUE(LoadExtension(app_dir));
 492   ASSERT_TRUE(RunExtensionTest("app_background_page/bg_open")) << message_;
 493 }
 494
 495 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, DISABLED_OpenThenClose) {
 496   host_resolver()->AddRule("a.com", "127.0.0.1");
 497   ASSERT_TRUE(StartEmbeddedTestServer());
 498
 499   std::string app_manifest = base::StringPrintf(
 500       "{"
 501       "  \"name\": \"App\","
 502       "  \"version\": \"0.1\","
 503       "  \"manifest_version\": 2,"
 504       "  \"app\": {"
 505       "    \"urls\": ["
 506       "      \"http://a.com/\""
 507       "    ],"
 508       "    \"launch\": {"
 509       "      \"web_url\": \"http://a.com:%u/\""
 510       "    }"
 511       "  },"
 512       "  \"permissions\": [\"background\"]"
 513       "}",
 514       embedded_test_server()->port());
 515
 516   base::FilePath app_dir;
 517   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 518   ASSERT_TRUE(LoadExtension(app_dir));
 519   // There isn't a background page loaded initially.
 520   const Extension* extension = GetSingleLoadedExtension();
 521   ASSERT_FALSE(
 522       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 523           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 524   // Background mode should not be active until a background page is created.
 525   ASSERT_TRUE(WaitForBackgroundMode(false));
 526   ASSERT_TRUE(RunExtensionTest("app_background_page/basic_open")) << message_;
 527   // Background mode should be active now because a background page was created.
 528   ASSERT_TRUE(WaitForBackgroundMode(true));
 529   ASSERT_TRUE(
 530       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 531           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 532   // Now close the BackgroundContents.
 533   ASSERT_TRUE(RunExtensionTest("app_background_page/basic_close")) << message_;
 534   // Background mode should no longer be active.
 535   ASSERT_TRUE(WaitForBackgroundMode(false));
 536   ASSERT_FALSE(
 537       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 538           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 539 }
 540
 541 IN_PROC_BROWSER_TEST_F(AppBackgroundPageApiTest, UnloadExtensionWhileHidden) {
 542   host_resolver()->AddRule("a.com", "127.0.0.1");
 543   ASSERT_TRUE(StartEmbeddedTestServer());
 544
 545   std::string app_manifest = base::StringPrintf(
 546       "{"
 547       "  \"name\": \"App\","
 548       "  \"version\": \"0.1\","
 549       "  \"manifest_version\": 2,"
 550       "  \"app\": {"
 551       "    \"urls\": ["
 552       "      \"http://a.com/\""
 553       "    ],"
 554       "    \"launch\": {"
 555       "      \"web_url\": \"http://a.com:%u/\""
 556       "    }"
 557       "  },"
 558       "  \"permissions\": [\"background\"],"
 559       "  \"background\": {"
 560       "    \"page\": \"http://a.com:%u/test.html\""
 561       "  }"
 562       "}",
 563       embedded_test_server()->port(),
 564       embedded_test_server()->port());
 565
 566   base::FilePath app_dir;
 567   ASSERT_TRUE(CreateApp(app_manifest, &app_dir));
 568   // Background mode should not be active now because no background app was
 569   // loaded.
 570   ASSERT_TRUE(LoadExtension(app_dir));
 571   // Background mode be active now because a background page was created when
 572   // the app was loaded.
 573   ASSERT_TRUE(WaitForBackgroundMode(true));
 574
 575   const Extension* extension = GetSingleLoadedExtension();
 576   ASSERT_TRUE(
 577       BackgroundContentsServiceFactory::GetForProfile(browser()->profile())->
 578           GetAppBackgroundContents(ASCIIToUTF16(extension->id())));
 579
 580   // Close all browsers - app should continue running.
 581   set_exit_when_last_browser_closes(false);
 582   CloseBrowserSynchronously(browser());
 583
 584   // Post a task to unload the extension - this should cause Chrome to exit
 585   // cleanly (not crash).
 586   UnloadExtensionViaTask(extension->id());
 587   content::RunAllPendingInMessageLoop();
 588   ASSERT_TRUE(WaitForBackgroundMode(false));
 589 }
 590
 591 // Verify active NaCl embeds cause many keepalive impulses to be sent.
 592 // Disabled on Windows due to flakiness: http://crbug.com/346278
 593 #if defined(OS_WIN)
 594 #define MAYBE_BackgroundKeepaliveActive DISABLED_BackgroundKeepaliveActive
 595 #else
 596 // Disabling other platforms too since the test started failing
 597 // consistently. http://crbug.com/490440
 598 #define MAYBE_BackgroundKeepaliveActive DISABLED_BackgroundKeepaliveActive
 599 #endif
 600 IN_PROC_BROWSER_TEST_F(AppBackgroundPageNaClTest,
 601                        MAYBE_BackgroundKeepaliveActive) {
 602 #if !defined(DISABLE_NACL)
 603   ExtensionTestMessageListener nacl_modules_loaded("nacl_modules_loaded", true);
 604   LaunchTestingApp();
 605   extensions::ProcessManager* manager =
 606       extensions::ProcessManager::Get(browser()->profile());
 607   ImpulseCallbackCounter active_impulse_counter(manager, extension()->id());
 608   EXPECT_TRUE(nacl_modules_loaded.WaitUntilSatisfied());
 609
 610   // Target .5 seconds: .5 seconds / 50ms throttle * 2 embeds == 20 impulses.
 611   manager->SetKeepaliveImpulseCallbackForTesting(
 612       active_impulse_counter.SetGoalAndGetCallback(20));
 613   active_impulse_counter.Wait();
 614 #endif
 615 }
 616
 617 // Verify that nacl modules that go idle will not send keepalive impulses.
 618 // Disabled on windows due to Win XP failures:
 619 // DesktopWindowTreeHostWin::HandleCreate not implemented. crbug.com/331954
 620 #if defined(OS_WIN)
 621 #define MAYBE_BackgroundKeepaliveIdle DISABLED_BackgroundKeepaliveIdle
 622 #else
 623 // ASAN errors appearing: https://crbug.com/332440
 624 #define MAYBE_BackgroundKeepaliveIdle DISABLED_BackgroundKeepaliveIdle
 625 #endif
 626 IN_PROC_BROWSER_TEST_F(AppBackgroundPageNaClTest,
 627                        MAYBE_BackgroundKeepaliveIdle) {
 628 #if !defined(DISABLE_NACL)
 629   ExtensionTestMessageListener nacl_modules_loaded("nacl_modules_loaded", true);
 630   LaunchTestingApp();
 631   extensions::ProcessManager* manager =
 632       extensions::ProcessManager::Get(browser()->profile());
 633   ImpulseCallbackCounter idle_impulse_counter(manager, extension()->id());
 634   EXPECT_TRUE(nacl_modules_loaded.WaitUntilSatisfied());
 635
 636   manager->SetKeepaliveImpulseDecrementCallbackForTesting(
 637       idle_impulse_counter.SetGoalAndGetCallback(1));
 638   nacl_modules_loaded.Reply("be idle");
 639   idle_impulse_counter.Wait();
 640 #endif
 641 }