DevTools: repair WorkerDevToolsSanityTest.InspectSharedWorker browser test

chrome/browser/devtools/devtools_sanity_browsertest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
@@ skipping 58 matching lines @@
     "files/devtools/pause_when_script_is_running.html";
 const char kPageWithContentScript[] =
     "files/devtools/page_with_content_script.html";
 const char kNavigateBackTestPage[] =
     "files/devtools/navigate_back.html";
 const char kChunkedTestPage[] = "chunked";
 const char kSlowTestPage[] =
     "chunked?waitBeforeHeaders=100&waitBetweenChunks=100&chunksNumber=2";
 const char kSharedWorkerTestPage[] =
     "files/workers/workers_ui_shared_worker.html";
+const char kSharedWorkerTestWorker[] =
+    "files/workers/workers_ui_shared_worker.js";
 const char kReloadSharedWorkerTestPage[] =
     "files/workers/debug_shared_worker_initialization.html";
+const char kReloadSharedWorkerTestWorker[] =
+    "files/workers/debug_shared_worker_initialization.js";
 
 void RunTestFunction(DevToolsWindow* window, const char* test_name) {
   std::string result;
 
   RenderViewHost* rvh = DevToolsWindowTesting::Get(window)->
       main_web_contents()->GetRenderViewHost();
   // At first check that JavaScript part of the front-end is loaded by
   // checking that global variable uiTests exists(it's created after all js
   // files have been loaded) and has runTest method.
   ASSERT_TRUE(
@@ skipping 309 matching lines @@
     int worker_process_id;
     int worker_route_id;
 
    private:
     friend class base::RefCountedThreadSafe<WorkerData>;
     ~WorkerData() {}
   };
 
   class WorkerCreationObserver : public WorkerServiceObserver {
    public:
-    explicit WorkerCreationObserver(WorkerData* worker_data)
-        : worker_data_(worker_data) {
-    }
+    explicit WorkerCreationObserver(const std::string& path,
+                                    WorkerData* worker_data)
+        : path_(path), worker_data_(worker_data) {}
 
    private:
     virtual ~WorkerCreationObserver() {}
 
     virtual void WorkerCreated (
         const GURL& url,
         const base::string16& name,
         int process_id,
         int route_id) override {
+      if (url.path().rfind(path_) == std::string::npos)
+        return;
       worker_data_->worker_process_id = process_id;
       worker_data_->worker_route_id = route_id;
       WorkerService::GetInstance()->RemoveObserver(this);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::MessageLoop::QuitClosure());
       delete this;
     }
+    std::string path_;
     scoped_refptr<WorkerData> worker_data_;
   };
 
   class WorkerTerminationObserver : public WorkerServiceObserver {
    public:
     explicit WorkerTerminationObserver(WorkerData* worker_data)
         : worker_data_(worker_data) {
     }
 
    private:
     virtual ~WorkerTerminationObserver() {}
 
     virtual void WorkerDestroyed(int process_id, int route_id) override {
       ASSERT_EQ(worker_data_->worker_process_id, process_id);
       ASSERT_EQ(worker_data_->worker_route_id, route_id);
       WorkerService::GetInstance()->RemoveObserver(this);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::MessageLoop::QuitClosure());
       delete this;
     }
     scoped_refptr<WorkerData> worker_data_;
   };
 
-  void RunTest(const char* test_name, const char* test_page) {
+  void RunTest(const char* test_name,
+               const char* test_page,
+               const char* worker_path) {
     ASSERT_TRUE(test_server()->Start());
     GURL url = test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
 
-    scoped_refptr<WorkerData> worker_data = WaitForFirstSharedWorker();
+    scoped_refptr<WorkerData> worker_data =
+        WaitForFirstSharedWorker(worker_path);
     OpenDevToolsWindowForSharedWorker(worker_data.get());
     RunTestFunction(window_, test_name);
     CloseDevToolsWindow();
   }
 
   static void TerminateWorkerOnIOThread(scoped_refptr<WorkerData> worker_data) {
     if (!WorkerService::GetInstance()->TerminateWorker(
         worker_data->worker_process_id, worker_data->worker_route_id))
       FAIL() << "Failed to terminate worker.\n";
     WorkerService::GetInstance()->AddObserver(
         new WorkerTerminationObserver(worker_data.get()));
   }
 
   static void TerminateWorker(scoped_refptr<WorkerData> worker_data) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&TerminateWorkerOnIOThread, worker_data));
     content::RunMessageLoop();
   }
 
   static void WaitForFirstSharedWorkerOnIOThread(
+      const std::string& path,
       scoped_refptr<WorkerData> worker_data) {
     std::vector<WorkerService::WorkerInfo> worker_info =
         WorkerService::GetInstance()->GetWorkers();
-    if (!worker_info.empty()) {
+    for (size_t i = 0; i < worker_info.size(); i++) {
+      if (worker_info[i].url.path().rfind(path) == std::string::npos)
+        continue;
       worker_data->worker_process_id = worker_info[0].process_id;
       worker_data->worker_route_id = worker_info[0].route_id;
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::MessageLoop::QuitClosure());
       return;
     }
 
     WorkerService::GetInstance()->AddObserver(
-        new WorkerCreationObserver(worker_data.get()));
+        new WorkerCreationObserver(path, worker_data.get()));
   }
 
-  static scoped_refptr<WorkerData> WaitForFirstSharedWorker() {
+  static scoped_refptr<WorkerData> WaitForFirstSharedWorker(const char* path) {
     scoped_refptr<WorkerData> worker_data(new WorkerData());
     BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&WaitForFirstSharedWorkerOnIOThread, worker_data));
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&WaitForFirstSharedWorkerOnIOThread, path, worker_data));
     content::RunMessageLoop();
     return worker_data;
   }
 
   void OpenDevToolsWindowForSharedWorker(WorkerData* worker_data) {
     Profile* profile = browser()->profile();
     scoped_refptr<DevToolsAgentHost> agent_host(
         DevToolsAgentHost::GetForWorker(
             worker_data->worker_process_id,
             worker_data->worker_route_id));
@@ skipping 340 matching lines @@
       content::ExecuteScriptAndExtractString(
           main_web_contents()->GetRenderViewHost(),
           "window.domAutomationController.send("
           "    '' + (window.uiTests && (typeof uiTests.runTest)));",
           &result));
   ASSERT_EQ("function", result) << "DevTools front-end is broken.";
   CloseDevToolsWindow();
 }
 
 // Flakily fails: http://crbug.com/403007 http://crbug.com/89845
-IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest, DISABLED_InspectSharedWorker) {
+IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest, InspectSharedWorker) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
     return;
 #endif
 
-  RunTest("testSharedWorker", kSharedWorkerTestPage);
+  RunTest("testSharedWorker", kSharedWorkerTestPage, kSharedWorkerTestWorker);
 }
 
 // http://crbug.com/100538
 IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest,
                        DISABLED_PauseInSharedWorkerInitialization) {
   ASSERT_TRUE(test_server()->Start());
   GURL url = test_server()->GetURL(kReloadSharedWorkerTestPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
-  scoped_refptr<WorkerData> worker_data = WaitForFirstSharedWorker();
+  scoped_refptr<WorkerData> worker_data =
+      WaitForFirstSharedWorker(kReloadSharedWorkerTestWorker);
   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.
   RunTestFunction(window_, "testPauseInSharedWorkerInitialization");
   CloseDevToolsWindow();
@@ skipping 29 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(RemoteDebuggingTest, RemoteDebugger) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
     return;
 #endif
 
   ASSERT_TRUE(RunExtensionTest("target_list")) << message_;
 }