ServiceWorker: Route unregister() through WebServiceWorkerRegistration for refactoring (2)

content/browser/service_worker/service_worker_dispatcher_host_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/browser/service_worker/service_worker_dispatcher_host.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
@@ skipping 81 matching lines @@
   void Register(int64 provider_id,
                 GURL pattern,
                 GURL worker_url,
                 uint32 expected_message) {
     SendRegister(provider_id, pattern, worker_url);
     EXPECT_TRUE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
         expected_message));
     dispatcher_host_->ipc_sink()->ClearMessages();
   }
 
+#ifdef CRBUG_500404
   void SendUnregister(int64 provider_id, GURL pattern) {
     dispatcher_host_->OnMessageReceived(
-        ServiceWorkerHostMsg_UnregisterServiceWorker(
+        ServiceWorkerHostMsg_DeprecatedUnregisterServiceWorker(
             -1, -1, provider_id, pattern));
     base::RunLoop().RunUntilIdle();
   }
 
   void Unregister(int64 provider_id, GURL pattern, uint32 expected_message) {
     SendUnregister(provider_id, pattern);
     EXPECT_TRUE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
         expected_message));
     dispatcher_host_->ipc_sink()->ClearMessages();
   }
+#else
+  void SendUnregister(int64 provider_id, int64 registration_id) {
+    dispatcher_host_->OnMessageReceived(
+        ServiceWorkerHostMsg_UnregisterServiceWorker(-1, -1, provider_id,
+                                                     registration_id));
+    base::RunLoop().RunUntilIdle();
+  }
+
+  void Unregister(int64 provider_id,
+                  int64 registration_id,
+                  uint32 expected_message) {
+    SendUnregister(provider_id, registration_id);
+    EXPECT_TRUE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
+        expected_message));
+    dispatcher_host_->ipc_sink()->ClearMessages();
+  }
+#endif  // CRBUG_500404
 
   void SendGetRegistration(int64 provider_id, GURL document_url) {
     dispatcher_host_->OnMessageReceived(
         ServiceWorkerHostMsg_GetRegistration(
             -1, -1, provider_id, document_url));
     base::RunLoop().RunUntilIdle();
   }
 
   void GetRegistration(int64 provider_id,
                        GURL document_url,
@@ skipping 52 matching lines @@
   const int64 kProviderId = 99;  // Dummy value
   scoped_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(host.Pass());
 
   Register(kProviderId,
            GURL("https://www.example.com/"),
            GURL("https://www.example.com/bar"),
            ServiceWorkerMsg_ServiceWorkerRegistrationError::ID);
-  Unregister(kProviderId,
-             GURL("https://www.example.com/"),
-             ServiceWorkerMsg_ServiceWorkerUnregistrationError::ID);
   GetRegistration(kProviderId,
                   GURL("https://www.example.com/"),
                   ServiceWorkerMsg_ServiceWorkerGetRegistrationError::ID);
   GetRegistrations(kProviderId,
                    ServiceWorkerMsg_ServiceWorkerGetRegistrationsError::ID);
+#ifdef CRBUG_500404

[kinuko, 2015/06/17 17:44:56]

I don't really understand why we still need these ifdefs.  When, where and how
are you going to add and remove the define?

Can't the old test code be just deleted if it's not going to pass, and can new
test code be added in the patch 4?

[nhiroki, 2015/06/17 23:23:48]

#define was already landed in the 1st patch and will be removed in the 3rd
patch. This #define is not used for enabling new codes, but for keeping existing
codes until the 3rd patch comes.
I meant to keep tests until the very last minute. If we delete these tests,
tests for both old and new codes are absent until the 4th patch comes, it may
not be a big deal for this small cleanup though.

+  Unregister(kProviderId, GURL("https://www.example.com/"),
+             ServiceWorkerMsg_ServiceWorkerUnregistrationError::ID);
+#else
+  // Add a registration into a live registration map so that Unregister() can
+  // find it.
+  const int64 kRegistrationId = 999;  // Dummy value
+  scoped_refptr<ServiceWorkerRegistration> registration(
+      new ServiceWorkerRegistration(GURL("https://www.example.com/"),
+                                    kRegistrationId, context()->AsWeakPtr()));
+  Unregister(kProviderId, kRegistrationId,
+             ServiceWorkerMsg_ServiceWorkerUnregistrationError::ID);
+#endif  // CRBUG_500404
 
   SetBrowserClientForTesting(old_browser_client);
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, Register_HTTPS) {
   const int64 kProviderId = 99;  // Dummy value
   scoped_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(host.Pass());
@@ skipping 138 matching lines @@
                GURL("https://www.example.com/temporary/"),
                GURL("filesystem:https://www.example.com/temporary/bar"));
   EXPECT_EQ(2, dispatcher_host_->bad_messages_received_count_);
 
   SendRegister(kProviderId,
                GURL("filesystem:https://www.example.com/temporary/"),
                GURL("filesystem:https://www.example.com/temporary/bar"));
   EXPECT_EQ(3, dispatcher_host_->bad_messages_received_count_);
 }
 
+// TODO(nhiroki): Remove these tests after http://crbug.com/500404 is fixed.
+#ifdef CRBUG_500404
 TEST_F(ServiceWorkerDispatcherHostTest, Unregister_HTTPS) {
   const int64 kProviderId = 99;  // Dummy value
   scoped_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(host.Pass());
 
   Unregister(kProviderId,
              GURL("https://www.example.com/"),
              ServiceWorkerMsg_ServiceWorkerUnregistered::ID);
@@ skipping 37 matching lines @@
 TEST_F(ServiceWorkerDispatcherHostTest, Unregister_NonSecureOriginShouldFail) {
   const int64 kProviderId = 99;  // Dummy value
   scoped_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("http://www.example.com/foo"));
   context()->AddProviderHost(host.Pass());
 
   SendUnregister(kProviderId, GURL("http://www.example.com/"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
+#endif  // CRBUG_500404
 
 TEST_F(ServiceWorkerDispatcherHostTest, EarlyContextDeletion) {
   helper_->ShutdownContext();
 
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   Register(-1,
            GURL(),
            GURL(),
@@ skipping 185 matching lines @@
 
   // To show the new dispatcher can operate, simulate provider creation. Since
   // the old dispatcher cleaned up the old provider host, the new one won't
   // complain.
   new_dispatcher_host->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW));
   EXPECT_EQ(0, new_dispatcher_host->bad_messages_received_count_);
 }
 
 }  // namespace content