ServiceWorker: Implement navigator.serviceWorker.getRegistration [2/3]

content/browser/service_worker/service_worker_context_unittest.cc

 // Copyright 2013 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 "content/public/browser/service_worker_context.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/browser_thread_impl.h"
@@ skipping 35 matching lines @@
 
 void CallCompletedCallback(bool* called, ServiceWorkerStatusCode) {
   *called = true;
 }
 
 ServiceWorkerContextCore::UnregistrationCallback MakeUnregisteredCallback(
     bool* called) {
   return base::Bind(&CallCompletedCallback, called);
 }
 
+void SaveRegistrationIdCallback(bool* called,
+                                int64* store_registration_id,
+                                ServiceWorkerStatusCode status,
+                                int64 registration_id) {
+  EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
+  *called = true;
+  *store_registration_id = registration_id;
+}
+
+ServiceWorkerContextCore::GetRegistrationCallback MakeGetRegistrationCallback(
+    bool* called,
+    int64* store_registration_id) {
+  return base::Bind(&SaveRegistrationIdCallback, called, store_registration_id);

[nhiroki, 2014/09/10 04:07:22]

nit: This indirection doesn't seem very helpful, others do the same thing
though.

[Kunihiko Sakamoto, 2014/09/10 08:22:44]

Agreed - inlined it.

+}
+
 void ExpectRegisteredWorkers(
     ServiceWorkerStatusCode expect_status,
     int64 expect_version_id,
     bool expect_waiting,
     bool expect_active,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   ASSERT_EQ(expect_status, status);
   if (status != SERVICE_WORKER_OK) {
     EXPECT_FALSE(registration.get());
@@ skipping 382 matching lines @@
       registration_id,
       GURL("http://www.example.com"),
       base::Bind(&ExpectRegisteredWorkers,
                  SERVICE_WORKER_OK,
                  version_id,
                  false /* expect_waiting */,
                  true /* expect_active */));
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_F(ServiceWorkerContextTest, GetRegistration) {
+  GURL pattern("http://www.example.com/");
+  GURL document_url("http://www.example.com/foo");
+
+  bool called = false;
+  int64 registration_id = kInvalidServiceWorkerRegistrationId;
+  int64 version_id = kInvalidServiceWorkerVersionId;
+  context()->RegisterServiceWorker(
+      pattern,
+      GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
+      NULL,
+      MakeRegisteredCallback(&called, &registration_id, &version_id));
+
+  ASSERT_FALSE(called);
+  base::RunLoop().RunUntilIdle();
+  ASSERT_TRUE(called);
+  EXPECT_NE(kInvalidServiceWorkerRegistrationId, registration_id);
+  EXPECT_NE(kInvalidServiceWorkerVersionId, version_id);
+
+  called = false;
+  int64 result_registration_id;
+  context()->GetRegistration(
+      document_url,
+      MakeGetRegistrationCallback(&called, &result_registration_id));
+
+  ASSERT_FALSE(called);
+  base::RunLoop().RunUntilIdle();
+  ASSERT_TRUE(called);
+  EXPECT_EQ(registration_id, result_registration_id);

[nhiroki, 2014/09/10 04:07:22]

Can you test a case that there is no registration for document_url?

[Kunihiko Sakamoto, 2014/09/10 08:22:44]

Done.

+}
+
 }  // namespace content