DevTools: fix and enable DevToolsExtensionDebugTest.TestContentScriptIsPresen...

chrome/browser/debugger/devtools_sanity_unittest.cc

 // Copyright (c) 2009 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/command_line.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/extensions/extensions_service.h"
@@ skipping 118 matching lines @@
     devtools_manager->UnregisterDevToolsClientHostFor(inspected_rvh_);
     BrowserClosedObserver close_observer(browser);
   }
 
   TabContents* client_contents_;
   DevToolsWindow* window_;
   RenderViewHost* inspected_rvh_;
 };
 
 
+class CancelableQuitTask : public Task {
+ public:
+  CancelableQuitTask(const std::string& timeout_message)
+      : timeout_message_(timeout_message),
+        cancelled_(false) {
+  }
+
+  void cancel() {
+    cancelled_ = true;
+  }
+
+  virtual void Run() {
+    if (cancelled_) {
+      return;
+    }
+    FAIL() << timeout_message_;
+    MessageLoop::current()->Quit();
+  }
+
+ private:
+  std::string timeout_message_;
+  bool cancelled_;
+};
+
+
 // Base class for DevTools tests that test devtools functionality for
 // extensions and content scripts.
 class DevToolsExtensionDebugTest : public DevToolsSanityTest,
                                    public NotificationObserver {
  public:
   DevToolsExtensionDebugTest() : DevToolsSanityTest() {
     PathService::Get(chrome::DIR_TEST_DATA, &test_extensions_dir_);
     test_extensions_dir_ = test_extensions_dir_.AppendASCII("devtools");
     test_extensions_dir_ = test_extensions_dir_.AppendASCII("extensions");
   }
 
  protected:
   // Load an extention from test\data\devtools\extensions\<extension_name>
   void LoadExtension(const char* extension_name) {
     FilePath path = test_extensions_dir_.AppendASCII(extension_name);
     ASSERT_TRUE(LoadExtensionFromPath(path)) << "Failed to load extension.";
   }
 
  private:
   bool LoadExtensionFromPath(const FilePath& path) {
     ExtensionsService* service = browser()->profile()->GetExtensionsService();
     size_t num_before = service->extensions()->size();
     {
       NotificationRegistrar registrar;
       registrar.Add(this, NotificationType::EXTENSION_LOADED,
                     NotificationService::AllSources());
-      MessageLoop::current()->PostDelayedTask(
-          FROM_HERE, new MessageLoop::QuitTask, 5*1000);
+      CancelableQuitTask* delayed_quit =
+          new CancelableQuitTask("Extension load timed out.");
+      MessageLoop::current()->PostDelayedTask(FROM_HERE, delayed_quit,
+          4*1000);
       service->LoadExtension(path);
       ui_test_utils::RunMessageLoop();
+      delayed_quit->cancel();
     }
     size_t num_after = service->extensions()->size();
-    return (num_after == (num_before + 1));
+    if (num_after != (num_before + 1))
+      return false;
+
+    return WaitForExtensionHostsToLoad();
+  }
+
+  bool WaitForExtensionHostsToLoad() {
+    // Wait for all the extension hosts that exist to finish loading.
+    // NOTE: This assumes that the extension host list is not changing while
+    // this method is running.
+
+    NotificationRegistrar registrar;
+    registrar.Add(this, NotificationType::EXTENSION_HOST_DID_STOP_LOADING,
+                  NotificationService::AllSources());
+    CancelableQuitTask* delayed_quit =
+        new CancelableQuitTask("Extension host load timed out.");
+    MessageLoop::current()->PostDelayedTask(FROM_HERE, delayed_quit,
+        4*1000);
+
+    ExtensionProcessManager* manager =
+          browser()->profile()->GetExtensionProcessManager();
+    for (ExtensionProcessManager::const_iterator iter = manager->begin();
+         iter != manager->end();) {
+      if ((*iter)->did_stop_loading())
+        ++iter;
+      else
+        ui_test_utils::RunMessageLoop();
+    }
+
+    delayed_quit->cancel();
+    return true;
   }
 
   void Observe(NotificationType type,
                const NotificationSource& source,
                const NotificationDetails& details) {
     switch (type.value) {
       case NotificationType::EXTENSION_LOADED:
-        std::cout << "Got EXTENSION_LOADED notification.\n";
+      case NotificationType::EXTENSION_HOST_DID_STOP_LOADING:
         MessageLoopForUI::current()->Quit();
         break;
-
       default:
         NOTREACHED();
         break;
     }
   }
 
   FilePath test_extensions_dir_;
 };
 
 
@@ skipping 27 matching lines @@
   RunTest("testProfilerTab", kJsPage);
 }
 
 // Tests scripts panel showing.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestShowScriptsTab) {
   RunTest("testShowScriptsTab", kDebuggerTestPage);
 }
 
 // Tests that a content script is in the scripts list.
 IN_PROC_BROWSER_TEST_F(DevToolsExtensionDebugTest,
-                       DISABLED_TestContentScriptIsPresent) {
+                       TestContentScriptIsPresent) {
   LoadExtension("simple_content_script");
   RunTest("testContentScriptIsPresent", kPageWithContentScript);
 }
 
 // Tests that scripts are not duplicated after Scripts Panel switch.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest,
                        TestNoScriptDuplicatesOnPanelSwitch) {
   RunTest("testNoScriptDuplicatesOnPanelSwitch", kDebuggerTestPage);
 }
 
@@ skipping 57 matching lines @@
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestConsoleLog) {
   RunTest("testConsoleLog", kConsoleTestPage);
 }
 
 // Tests eval global values.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestEvalGlobal) {
   RunTest("testEvalGlobal", kEvalTestPage);
 }
 
 }  // namespace