Start EmbeddedWorker during registration - take 2

content/browser/service_worker/service_worker_job_unittest.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/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
+#include "content/browser/service_worker/embedded_worker_registry.h"
+#include "content/browser/service_worker/embedded_worker_test_helper.h"
+#include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_registration_status.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "ipc/ipc_test_sink.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Unit tests for testing all job registration tasks.
 namespace content {
 
 namespace {
 
 void SaveRegistrationCallback(
     ServiceWorkerStatusCode expected_status,
     bool* called,
@@ skipping 61 matching lines @@
 }
 
 }  // namespace
 
 class ServiceWorkerJobTest : public testing::Test {
  public:
   ServiceWorkerJobTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   virtual void SetUp() OVERRIDE {
-    storage_.reset(new ServiceWorkerStorage(base::FilePath(), NULL));
-    job_coordinator_.reset(new ServiceWorkerJobCoordinator(storage_.get()));
+    context_.reset(new ServiceWorkerContextCore(base::FilePath(), NULL));
+    helper_.reset(new EmbeddedWorkerTestHelper(context_.get()));
+
+    storage_ = context_->storage();
+    job_coordinator_ = context_->job_coordinator();
+
+    scoped_ptr<EmbeddedWorkerInstance> worker =
+        context_->embedded_worker_registry()->CreateWorker();
+
+    render_process_id_ = 88;
+    int embedded_worker_id = worker->embedded_worker_id();
+    helper_->SimulateAddProcess(embedded_worker_id, render_process_id_);
   }
 
-  virtual void TearDown() OVERRIDE { storage_.reset(); }
+  virtual void TearDown() OVERRIDE {
+    helper_.reset();
+    context_.reset();
+  }
 
  protected:
   TestBrowserThreadBundle browser_thread_bundle_;
-  scoped_ptr<ServiceWorkerStorage> storage_;
-  scoped_ptr<ServiceWorkerJobCoordinator> job_coordinator_;
+  scoped_ptr<ServiceWorkerContextCore> context_;
+  scoped_ptr<EmbeddedWorkerTestHelper> helper_;
+
+  // these are just shortcuts into context_ above
+  ServiceWorkerStorage* storage_;
+  ServiceWorkerJobCoordinator* job_coordinator_;

[kinuko, 2014/02/04 03:37:53]

nit: could we instead have accessors like storage() and job_coordinator() ?

(If you prefer having these fields please initialize them with NULL in ctor)

[alecflett, 2014/02/04 20:09:04]

Done.

+
+  int render_process_id_;

[kinuko, 2014/02/04 03:37:53]

Please initialize this in ctor (with -1 etc)

[alecflett, 2014/02/04 20:09:04]

Done.

 };
 
 TEST_F(ServiceWorkerJobTest, SameDocumentSameRegistration) {
   scoped_refptr<ServiceWorkerRegistration> original_registration;
   bool called;
   job_coordinator_->Register(
       GURL("http://www.example.com/*"),
       GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &original_registration));
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
   storage_->FindRegistrationForDocument(
       GURL("http://www.example.com/"),
       SaveFoundRegistration(true, SERVICE_WORKER_OK, &called, &registration1));
   scoped_refptr<ServiceWorkerRegistration> registration2;
@@ skipping 12 matching lines @@
 
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, SameMatchSameRegistration) {
   bool called;
   scoped_refptr<ServiceWorkerRegistration> original_registration;
   job_coordinator_->Register(
       GURL("http://www.example.com/*"),
       GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &original_registration));
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_NE(static_cast<ServiceWorkerRegistration*>(NULL),
             original_registration.get());
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
   storage_->FindRegistrationForDocument(
       GURL("http://www.example.com/one"),
@@ skipping 13 matching lines @@
 
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, DifferentMatchDifferentRegistration) {
   bool called1;
   scoped_refptr<ServiceWorkerRegistration> original_registration1;
   job_coordinator_->Register(
       GURL("http://www.example.com/one/*"),
       GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called1, &original_registration1));
 
   bool called2;
   scoped_refptr<ServiceWorkerRegistration> original_registration2;
   job_coordinator_->Register(
       GURL("http://www.example.com/two/*"),
       GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called2, &original_registration2));
 
   EXPECT_FALSE(called1);
   EXPECT_FALSE(called2);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called1);
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
   storage_->FindRegistrationForDocument(
@@ skipping 13 matching lines @@
   ASSERT_NE(registration1, registration2);
 }
 
 // Make sure basic registration is working.
 TEST_F(ServiceWorkerJobTest, Register) {
   bool called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator_->Register(
       GURL("http://www.example.com/*"),
       GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_NE(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 }
 
 // Make sure registrations are cleaned up when they are unregistered.
 TEST_F(ServiceWorkerJobTest, Unregister) {
   GURL pattern("http://www.example.com/*");
 
   bool called;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator_->Register(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   job_coordinator_->Unregister(pattern,
+                               render_process_id_,
                                SaveUnregistration(SERVICE_WORKER_OK, &called));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_TRUE(registration->HasOneRef());
 
   storage_->FindRegistrationForPattern(
       pattern,
       SaveFoundRegistration(false, SERVICE_WORKER_OK, &called, &registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 }
 
 // Make sure that when a new registration replaces an existing
 // registration, that the old one is cleaned up.
 TEST_F(ServiceWorkerJobTest, RegisterNewScript) {
   GURL pattern("http://www.example.com/*");
 
   bool called;
   scoped_refptr<ServiceWorkerRegistration> old_registration;
   job_coordinator_->Register(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &old_registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern;
   storage_->FindRegistrationForPattern(
       pattern,
       SaveFoundRegistration(
           true, SERVICE_WORKER_OK, &called, &old_registration_by_pattern));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_EQ(old_registration, old_registration_by_pattern);
   old_registration_by_pattern = NULL;
 
   scoped_refptr<ServiceWorkerRegistration> new_registration;
   job_coordinator_->Register(
       pattern,
       GURL("http://www.example.com/service_worker_new.js"),
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &new_registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_TRUE(old_registration->HasOneRef());
 
   ASSERT_NE(old_registration, new_registration);
 
@@ skipping 14 matching lines @@
 // combination, that the same registration is used.
 TEST_F(ServiceWorkerJobTest, RegisterDuplicateScript) {
   GURL pattern("http://www.example.com/*");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool called;
   scoped_refptr<ServiceWorkerRegistration> old_registration;
   job_coordinator_->Register(
       pattern,
       script_url,
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &old_registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern;
   storage_->FindRegistrationForPattern(
       pattern,
       SaveFoundRegistration(
           true, SERVICE_WORKER_OK, &called, &old_registration_by_pattern));
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_TRUE(old_registration_by_pattern);
 
   scoped_refptr<ServiceWorkerRegistration> new_registration;
   job_coordinator_->Register(
       pattern,
       script_url,
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &new_registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_EQ(old_registration, new_registration);
 
   ASSERT_FALSE(old_registration->HasOneRef());
 
@@ skipping 14 matching lines @@
 // process jobs until the last job.
 TEST_F(ServiceWorkerJobTest, ParallelRegUnreg) {
   GURL pattern("http://www.example.com/*");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool registration_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator_->Register(
       pattern,
       script_url,
+      render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &registration_called, &registration));
 
   bool unregistration_called = false;
   job_coordinator_->Unregister(
-      pattern, SaveUnregistration(SERVICE_WORKER_OK, &unregistration_called));
+      pattern,
+      render_process_id_,
+      SaveUnregistration(SERVICE_WORKER_OK, &unregistration_called));
 
   ASSERT_FALSE(registration_called);
   ASSERT_FALSE(unregistration_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration_called);
   ASSERT_TRUE(unregistration_called);
 
   ASSERT_TRUE(registration->is_shutdown());
 
   bool find_called = false;
@@ skipping 12 matching lines @@
 // shutdown.
 TEST_F(ServiceWorkerJobTest, ParallelRegNewScript) {
   GURL pattern("http://www.example.com/*");
 
   GURL script_url1("http://www.example.com/service_worker1.js");
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator_->Register(
       pattern,
       script_url1,
-      SaveRegistration(SERVICE_WORKER_OK, &registration1_called,
-                       &registration1));
+      render_process_id_,
+      SaveRegistration(
+          SERVICE_WORKER_OK, &registration1_called, &registration1));
 
   GURL script_url2("http://www.example.com/service_worker2.js");
   bool registration2_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator_->Register(
       pattern,
       script_url2,
-      SaveRegistration(SERVICE_WORKER_OK, &registration2_called,
-                       &registration2));
+      render_process_id_,
+      SaveRegistration(
+          SERVICE_WORKER_OK, &registration2_called, &registration2));
 
   ASSERT_FALSE(registration1_called);
   ASSERT_FALSE(registration2_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration1_called);
   ASSERT_TRUE(registration2_called);
 
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool find_called = false;
   storage_->FindRegistrationForPattern(
@@ skipping 13 matching lines @@
 // object.
 TEST_F(ServiceWorkerJobTest, ParallelRegSameScript) {
   GURL pattern("http://www.example.com/*");
 
   GURL script_url("http://www.example.com/service_worker1.js");
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator_->Register(
       pattern,
       script_url,
-      SaveRegistration(SERVICE_WORKER_OK, &registration1_called,
-                       &registration1));
+      render_process_id_,
+      SaveRegistration(
+          SERVICE_WORKER_OK, &registration1_called, &registration1));
 
   bool registration2_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator_->Register(
       pattern,
       script_url,
-      SaveRegistration(SERVICE_WORKER_OK, &registration2_called,
-                       &registration2));
+      render_process_id_,
+      SaveRegistration(
+          SERVICE_WORKER_OK, &registration2_called, &registration2));
 
   ASSERT_FALSE(registration1_called);
   ASSERT_FALSE(registration2_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration1_called);
   ASSERT_TRUE(registration2_called);
 
   ASSERT_EQ(registration1, registration2);
 
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool find_called = false;
   storage_->FindRegistrationForPattern(
       pattern,
       SaveFoundRegistration(
           true, SERVICE_WORKER_OK, &find_called, &registration));
 
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(registration, registration1);
 }
 
 // Call simulataneous unregister calls.
 TEST_F(ServiceWorkerJobTest, ParallelUnreg) {
   GURL pattern("http://www.example.com/*");
 
   GURL script_url("http://www.example.com/service_worker.js");
   bool unregistration1_called = false;
   job_coordinator_->Unregister(
-      pattern, SaveUnregistration(SERVICE_WORKER_OK, &unregistration1_called));
+      pattern,
+      render_process_id_,
+      SaveUnregistration(SERVICE_WORKER_OK, &unregistration1_called));
 
   bool unregistration2_called = false;
   job_coordinator_->Unregister(
-      pattern, SaveUnregistration(SERVICE_WORKER_OK, &unregistration2_called));
+      pattern,
+      render_process_id_,
+      SaveUnregistration(SERVICE_WORKER_OK, &unregistration2_called));
 
   ASSERT_FALSE(unregistration1_called);
   ASSERT_FALSE(unregistration2_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(unregistration1_called);
   ASSERT_TRUE(unregistration2_called);
 
   // There isn't really a way to test that they are being coalesced,
   // but we can make sure they can exist simultaneously without
   // crashing.
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool find_called = false;
   storage_->FindRegistrationForPattern(
       pattern,
       SaveFoundRegistration(
           false, SERVICE_WORKER_OK, &find_called, &registration));
 
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 }  // namespace content