Save running SW instance info, including its SiteInstance, into the ProcessManager.

content/browser/service_worker/service_worker_browsertest.cc

 // Copyright 2014 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/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
@@ skipping 532 matching lines @@
  public:
   typedef ServiceWorkerBlackBoxBrowserTest self;
 
   static void ExpectResultAndRun(bool expected,
                                  const base::Closure& continuation,
                                  bool actual) {
     EXPECT_EQ(expected, actual);
     continuation.Run();
   }
 
-  int RenderProcessID() {
-    return shell()->web_contents()->GetRenderProcessHost()->GetID();
-  }
-
   void FindRegistrationOnIO(const GURL& document_url,
                             ServiceWorkerStatusCode* status,
                             GURL* script_url,
                             const base::Closure& continuation) {
     wrapper()->context()->storage()->FindRegistrationForDocument(
         document_url,
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::FindRegistrationOnIO2,
                    this,
                    status,
                    script_url,
                    continuation));
   }
 
   void FindRegistrationOnIO2(
       ServiceWorkerStatusCode* out_status,
       GURL* script_url,
       const base::Closure& continuation,
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration) {
     *out_status = status;
     if (registration) {
       *script_url = registration->script_url();
     } else {
       EXPECT_NE(SERVICE_WORKER_OK, status);
     }
     continuation.Run();
   }
 };
 
+static int CountRenderProcessHosts() {
+  int result = 0;
+  for (RenderProcessHost::iterator iter(RenderProcessHost::AllHostsIterator());
+       !iter.IsAtEnd();
+       iter.Advance()) {
+    result++;
+  }
+  return result;
+}
+
 IN_PROC_BROWSER_TEST_F(ServiceWorkerBlackBoxBrowserTest, Registration) {
+  // Close the only window to be sure we're not re-using its RenderProcessHost.
+  shell()->Close();
+  EXPECT_EQ(0, CountRenderProcessHosts());
+
   const std::string kWorkerUrl = "/service_worker/fetch_event.js";
 
   // Unregistering nothing should return true.
   {
     base::RunLoop run_loop;
     public_context()->UnregisterServiceWorker(
         embedded_test_server()->GetURL("/*"),
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::ExpectResultAndRun,
                    true,
                    run_loop.QuitClosure()));
     run_loop.Run();
   }
 
+  // If we use a worker URL that doesn't exist, registration fails.
+  {
+    base::RunLoop run_loop;
+    public_context()->RegisterServiceWorker(
+        embedded_test_server()->GetURL("/*"),
+        embedded_test_server()->GetURL("/does/not/exist"),
+        base::Bind(&ServiceWorkerBlackBoxBrowserTest::ExpectResultAndRun,
+                   false,
+                   run_loop.QuitClosure()));
+    run_loop.Run();
+  }
+  EXPECT_EQ(0, CountRenderProcessHosts());
+
   // Register returns when the promise would be resolved.
   {
     base::RunLoop run_loop;
     public_context()->RegisterServiceWorker(
         embedded_test_server()->GetURL("/*"),
         embedded_test_server()->GetURL(kWorkerUrl),
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::ExpectResultAndRun,
                    true,
                    run_loop.QuitClosure()));
     run_loop.Run();
   }
+  EXPECT_EQ(1, CountRenderProcessHosts());
 
   // Registering again should succeed, although the algo still
   // might not be complete.
   {
     base::RunLoop run_loop;
     public_context()->RegisterServiceWorker(
         embedded_test_server()->GetURL("/*"),
         embedded_test_server()->GetURL(kWorkerUrl),
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::ExpectResultAndRun,
                    true,
                    run_loop.QuitClosure()));
     run_loop.Run();
   }
 
   // The registration algo might not be far enough along to have
   // stored the registration data, so it may not be findable
   // at this point.
 
   // Unregistering something should return true.
   {
     base::RunLoop run_loop;
     public_context()->UnregisterServiceWorker(
         embedded_test_server()->GetURL("/*"),
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::ExpectResultAndRun,
                    true,
                    run_loop.QuitClosure()));
     run_loop.Run();
   }
+  EXPECT_LE(CountRenderProcessHosts(), 1) << "Unregistering doesn't stop the "

[dominicc (has gone to gerrit), 2014/05/20 02:01:18]

Isn't it expected, actual?

[Jeffrey Yasskin, 2014/05/20 05:20:10]

For EQ and NE, yes. For the inequalities,
https://code.google.com/p/chromium/codesearch/#chromium/src/testing/gtest/inc...
just uses 'val1' and 'val2'. I can switch it if you prefer though.

I also suspect that Kinuko's CL to stop the worker when its last instance goes
away will let me change this to an EXPECT_EQ(0, ...).

[kinuko, 2014/05/20 06:30:03]

Ah yes, that might be the case.

+                                             "workers eagerly, so their RPHs "
+                                             "can still be running.";
 
   // Should not be able to find it.
   {
     ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
     GURL script_url;
     RunOnIOThread(
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::FindRegistrationOnIO,
                    this,
                    embedded_test_server()->GetURL("/service_worker/empty.html"),
                    &status,
                    &script_url));
     EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND, status);
   }
 }
 
 }  // namespace content