Create ServiceWorkerProviderHost before starting worker

content/browser/payments/payment_app_content_unittest_base.cc

 // Copyright 2016 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/payments/payment_app_content_unittest_base.h"
 
 #include <stdint.h>
 
 #include <set>
 #include <utility>
@@ skipping 10 matching lines @@
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/service_manager/public/cpp/bind_source_info.h"
 
 namespace content {
 
 namespace {
 
 void RegisterServiceWorkerCallback(bool* called,
+                                   int64_t* out_registration_id,
                                    ServiceWorkerStatusCode status,
                                    const std::string& status_message,
                                    int64_t registration_id) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   *called = true;
+  *out_registration_id = registration_id;
 }
 
 void UnregisterServiceWorkerCallback(bool* called,
                                      ServiceWorkerStatusCode status) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   *called = true;
 }
 
+void StopWorkerCallback(bool* called, ServiceWorkerStatusCode status) {
+  EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
+  *called = true;
+}
+
 }  // namespace
 
 class PaymentAppContentUnitTestBase::PaymentAppForWorkerTestHelper
     : public EmbeddedWorkerTestHelper {
  public:
   PaymentAppForWorkerTestHelper()
       : EmbeddedWorkerTestHelper(base::FilePath()),
         last_sw_registration_id_(kInvalidServiceWorkerRegistrationId) {}
   ~PaymentAppForWorkerTestHelper() override {}
 
-  void OnStartWorker(int embedded_worker_id,
-                     int64_t service_worker_version_id,
-                     const GURL& scope,
-                     const GURL& script_url,
-                     bool pause_after_download,
-                     mojom::ServiceWorkerEventDispatcherRequest request,
-                     mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo
-                         instance_host) override {
+  void OnStartWorker(
+      int embedded_worker_id,
+      int64_t service_worker_version_id,
+      const GURL& scope,
+      const GURL& script_url,
+      bool pause_after_download,
+      mojom::ServiceWorkerEventDispatcherRequest request,
+      mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host,
+      mojom::ServiceWorkerProviderClientInfoPtr provider_client_info) override {
     ServiceWorkerVersion* version =
         context()->GetLiveVersion(service_worker_version_id);
     last_sw_registration_id_ = version->registration_id();
     last_sw_scope_ = scope;
     EmbeddedWorkerTestHelper::OnStartWorker(
         embedded_worker_id, service_worker_version_id, scope, script_url,
-        pause_after_download, std::move(request), std::move(instance_host));
+        pause_after_download, std::move(request), std::move(instance_host),
+        std::move(provider_client_info));
   }
 
   void OnPaymentRequestEvent(
       payments::mojom::PaymentAppRequestPtr app_request,
       payments::mojom::PaymentAppResponseCallbackPtr response_callback,
       mojom::ServiceWorkerEventDispatcher::DispatchPaymentRequestEventCallback
           callback) override {
     EmbeddedWorkerTestHelper::OnPaymentRequestEvent(
         std::move(app_request), std::move(response_callback),
         std::move(callback));
@@ skipping 25 matching lines @@
 BrowserContext* PaymentAppContentUnitTestBase::browser_context() {
   DCHECK(worker_helper_);
   return worker_helper_->browser_context();
 }
 
 PaymentManager* PaymentAppContentUnitTestBase::CreatePaymentManager(
     const GURL& scope_url,
     const GURL& sw_script_url) {
   // Register service worker for payment manager.
   bool called = false;
+  int64_t registration_id;
   worker_helper_->context()->RegisterServiceWorker(
       scope_url, sw_script_url, nullptr,
-      base::Bind(&RegisterServiceWorkerCallback, &called));
+      base::Bind(&RegisterServiceWorkerCallback, &called, &registration_id));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
+  // Ensure the worker used for installation has stopped.
+  called = false;
+  ServiceWorkerRegistration* registration =
+      worker_helper_->context()->GetLiveRegistration(registration_id);
+  EXPECT_TRUE(registration);

[falken, 2017/06/06 14:06:33]

ASSERT, since the other EXPECTs don't make sense if false (we'd crash)

[shimazu, 2017/06/12 06:08:12]

We seems not to be able to use ASSERT in functions whose return type is not
void. 
Do you have any typical ways to handle the situation?
Returning nullptr and handle that on the caller is one possible way, but I feel
it's a bit tough because all of callers should have a null check. 

[falken, 2017/06/12 07:01:28]

Ah didn't know that. I guess we just use EXPECT here then.

+  EXPECT_TRUE(registration->active_version());
+  EXPECT_FALSE(registration->waiting_version());
+  EXPECT_FALSE(registration->installing_version());
+  registration->active_version()->StopWorker(
+      base::Bind(&StopWorkerCallback, &called));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(called);
+
   // This function should eventually return created payment manager
   // but there is no way to get last created payment manager from
   // payment_app_context()->payment_managers_ because its type is std::map
   // and can not ensure its order. So, just make a set of existing payment app
   // managers before creating a new manager and then check what is a new thing.
   std::set<PaymentManager*> existing_managers;
   for (const auto& existing_manager :
        payment_app_context()->payment_managers_) {
     existing_managers.insert(existing_manager.first);
   }
@@ skipping 42 matching lines @@
 StoragePartitionImpl* PaymentAppContentUnitTestBase::storage_partition() {
   return static_cast<StoragePartitionImpl*>(
       BrowserContext::GetDefaultStoragePartition(browser_context()));
 }
 
 PaymentAppContextImpl* PaymentAppContentUnitTestBase::payment_app_context() {
   return storage_partition()->GetPaymentAppContext();
 }
 
 }  // namespace content