DevTools: test that debugger can be paused in shared worker initialization code

Added a test that navigates to a page which launches a shared worker, opens devtools for the worker, terminates the worker and reloads the page to recreate the worker. After that the test checks that debugger is paused on the debugger statement(which is the first one) in the reloaded worker.

BUG=None
TEST=WorkerDevToolsSanityTest.PauseInSharedWorkerInitialization

Review URL: http://codereview.chromium.org/8208012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@105773 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 78 insertions, 2 deletions

diff --git a/chrome/browser/debugger/devtools_sanity_unittest.cc b/chrome/browser/debugger/devtools_sanity_unittest.cc
index d0f28f1..d16c2cd 100644
--- a/chrome/browser/debugger/devtools_sanity_unittest.cc
+++ b/chrome/browser/debugger/devtools_sanity_unittest.cc
@@ -28,6 +28,7 @@
 #include "content/browser/worker_host/worker_service_observer.h"
 #include "content/common/notification_registrar.h"
 #include "content/common/notification_service.h"
+#include "content/common/worker_messages.h"
 #include "net/test/test_server.h"
 
 namespace {
@@ -70,6 +71,8 @@ const char kSlowTestPage[] =
     "chunked?waitBeforeHeaders=100&waitBetweenChunks=100&chunksNumber=2";
 const char kSharedWorkerTestPage[] =
     "files/workers/workers_ui_shared_worker.html";
+const char kReloadSharedWorkerTestPage[] =
+    "files/workers/debug_shared_worker_initialization.html";
 
 void RunTestFuntion(DevToolsWindow* window, const char* test_name) {
   std::string result;
@@ -302,16 +305,67 @@ class WorkerDevToolsSanityTest : public InProcessBrowserTest {
     scoped_refptr<WorkerData> worker_data_;
   };
 
+  class WorkerTerminationObserver : public WorkerServiceObserver {
+   public:
+    explicit WorkerTerminationObserver(WorkerData* worker_data)
+        : worker_data_(worker_data) {
+    }
+
+   private:
+    virtual ~WorkerTerminationObserver() {}
+
+    virtual void WorkerCreated (
+        WorkerProcessHost* process,
+        const WorkerProcessHost::WorkerInstance& instance) OVERRIDE {}
+    virtual void WorkerDestroyed(
+        WorkerProcessHost* process,
+        const WorkerProcessHost::WorkerInstance& instance) OVERRIDE {
+      ASSERT_EQ(worker_data_->worker_process_id, process->id());
+      ASSERT_EQ(worker_data_->worker_route_id, instance.worker_route_id());
+      WorkerService::GetInstance()->RemoveObserver(this);
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+          new MessageLoop::QuitTask);
+      delete this;
+    }
+    virtual void WorkerContextStarted(
+        WorkerProcessHost*,
+        int worker_route_id) OVERRIDE {}
+    scoped_refptr<WorkerData> worker_data_;
+  };
+
   void RunTest(const char* test_name, const char* test_page) {
     ASSERT_TRUE(test_server()->Start());
     GURL url = test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
 
-    OpenDevToolsWindowForFirstSharedWorker();
+    scoped_refptr<WorkerData> worker_data = WaitForFirstSharedWorker();
+    OpenDevToolsWindowForSharedWorker(worker_data.get());
     RunTestFuntion(window_, test_name);
     CloseDevToolsWindow();
   }
 
+  static void TerminateWorkerOnIOThread(
+      scoped_refptr<WorkerData> worker_data) {
+    for (BrowserChildProcessHost::Iterator iter(
+             ChildProcessInfo::WORKER_PROCESS);
+         !iter.Done(); ++iter) {
+      if (iter->id() == worker_data->worker_process_id) {
+        (*iter)->Send(new WorkerMsg_TerminateWorkerContext(
+            worker_data->worker_route_id));
+        WorkerService::GetInstance()->AddObserver(
+            new WorkerTerminationObserver(worker_data));
+        return;
+      }
+    }
+    FAIL() << "Failed to terminate worker.\n";
+  }
+
+  static void TerminateWorker(scoped_refptr<WorkerData> worker_data) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, NewRunnableFunction(
+        &TerminateWorkerOnIOThread, worker_data));
+    ui_test_utils::RunMessageLoop();
+  }
+
   static void WaitForFirstSharedWorkerOnIOThread(
       scoped_refptr<WorkerData> worker_data) {
     BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
@@ -334,12 +388,15 @@ class WorkerDevToolsSanityTest : public InProcessBrowserTest {
         new WorkerCreationObserver(worker_data.get()));
   }
 
-  void OpenDevToolsWindowForFirstSharedWorker() {
+  static scoped_refptr<WorkerData> WaitForFirstSharedWorker() {
     scoped_refptr<WorkerData> worker_data(new WorkerData());
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, NewRunnableFunction(
         &WaitForFirstSharedWorkerOnIOThread, worker_data));
     ui_test_utils::RunMessageLoop();
+    return worker_data;
+  }
 
+  void OpenDevToolsWindowForSharedWorker(WorkerData* worker_data) {
     Profile* profile = browser()->profile();
     window_ = DevToolsWindow::CreateDevToolsWindowForWorker(profile);
     window_->Show(DEVTOOLS_TOGGLE_ACTION_NONE);
@@ -461,4 +518,23 @@ IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest, DISABLED_InspectSharedWorker) {
   RunTest("testSharedWorker", kSharedWorkerTestPage);
 }
 
+IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest,
+                       PauseInSharedWorkerInitialization) {
+    ASSERT_TRUE(test_server()->Start());
+    GURL url = test_server()->GetURL(kReloadSharedWorkerTestPage);
+    ui_test_utils::NavigateToURL(browser(), url);
+
+    scoped_refptr<WorkerData> worker_data = WaitForFirstSharedWorker();
+    OpenDevToolsWindowForSharedWorker(worker_data.get());
+
+    TerminateWorker(worker_data);
+
+    // Reload page to restart the worker.
+    ui_test_utils::NavigateToURL(browser(), url);
+
+    // Wait until worker script is paused on the debugger statement.
+    RunTestFuntion(window_, "testPauseInSharedWorkerInitialization");
+    CloseDevToolsWindow();
+}
+
 }  // namespace