Reset fetch_dispatcher_ in ServiceWorkerVersionBrowserTest on IO thread.

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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 93 matching lines @@
 }
 
 void ReceivePrepareResult(bool* is_prepared) {
   *is_prepared = true;
 }
 
 base::Closure CreatePrepareReceiver(bool* is_prepared) {
   return base::Bind(&ReceivePrepareResult, is_prepared);
 }
 
-// Contrary to the style guide, the output parameter of this function comes
-// before input parameters so Bind can be used on it to create a FetchCallback
-// to pass to DispatchFetchEvent.
-void ReceiveFetchResult(BrowserThread::ID run_quit_thread,
-                        const base::Closure& quit,
-                        ChromeBlobStorageContext* blob_context,
-                        FetchResult* out_result,
-                        ServiceWorkerStatusCode actual_status,
-                        ServiceWorkerFetchEventResult actual_result,
-                        const ServiceWorkerResponse& actual_response,
-                        const scoped_refptr<ServiceWorkerVersion>& worker) {
-  out_result->status = actual_status;
-  out_result->result = actual_result;
-  out_result->response = actual_response;
-  if (!actual_response.blob_uuid.empty()) {
-    out_result->blob_data_handle =
-        blob_context->context()->GetBlobDataFromUUID(
-            actual_response.blob_uuid);
-  }
-  if (!quit.is_null())
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, quit);
-}
-
-ServiceWorkerFetchDispatcher::FetchCallback CreateResponseReceiver(
-    BrowserThread::ID run_quit_thread,
-    const base::Closure& quit,
-    ChromeBlobStorageContext* blob_context,
-    FetchResult* result) {
-  return base::Bind(&ReceiveFetchResult, run_quit_thread, quit,
-                    make_scoped_refptr<ChromeBlobStorageContext>(blob_context),
-                    result);
-}
-
 void ReceiveFindRegistrationStatus(
     BrowserThread::ID run_quit_thread,
     const base::Closure& quit,
     ServiceWorkerStatusCode* out_status,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   *out_status = status;
   if (!quit.is_null())
     BrowserThread::PostTask(run_quit_thread, FROM_HERE, quit);
 }
@@ skipping 286 matching lines @@
     base::RunLoop fetch_run_loop;
     BrowserThread::PostTask(BrowserThread::IO,
                             FROM_HERE,
                             base::Bind(&self::FetchOnIOThread,
                                        this,
                                        fetch_run_loop.QuitClosure(),
                                        &prepare_result,
                                        &fetch_result));
     fetch_run_loop.Run();
     ASSERT_TRUE(prepare_result);
-    ASSERT_TRUE(fetch_dispatcher_);
     *result = fetch_result.result;
     *response = fetch_result.response;
     *blob_data_handle = std::move(fetch_result.blob_data_handle);
-    fetch_dispatcher_.reset();
     ASSERT_EQ(SERVICE_WORKER_OK, fetch_result.status);
   }
 
   void FetchTestHelper(const std::string& worker_url,
                        ServiceWorkerFetchEventResult* result,
                        ServiceWorkerResponse* response,
                        scoped_ptr<storage::BlobDataHandle>* blob_data_handle) {
     RunOnIOThread(
         base::Bind(&self::SetUpRegistrationOnIOThread, this, worker_url));
     FetchOnRegisteredWorker(result, response, blob_data_handle);
@@ skipping 190 matching lines @@
                        bool* prepare_result,
                        FetchResult* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
         embedded_test_server()->GetURL("/service_worker/empty.html"), "GET",
         ServiceWorkerHeaderMap(), Referrer(), false));
     version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
     fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
         std::move(request), version_.get(),
         CreatePrepareReceiver(prepare_result),
-        CreateResponseReceiver(BrowserThread::UI, done, blob_context_.get(),
-                               result)));
+        CreateResponseReceiver(done, blob_context_.get(), result)));
     fetch_dispatcher_->Run();
   }
 
+  // Contrary to the style guide, the output parameter of this function comes
+  // before input parameters so Bind can be used on it to create a FetchCallback
+  // to pass to DispatchFetchEvent.
+  void ReceiveFetchResultOnIOThread(
+      const base::Closure& quit,
+      ChromeBlobStorageContext* blob_context,
+      FetchResult* out_result,
+      ServiceWorkerStatusCode actual_status,
+      ServiceWorkerFetchEventResult actual_result,
+      const ServiceWorkerResponse& actual_response,
+      const scoped_refptr<ServiceWorkerVersion>& worker) {

[nhiroki, 2016/03/01 05:58:15]

ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));

[horo, 2016/03/01 07:02:23]

Done.

+    ASSERT_TRUE(fetch_dispatcher_);
+    fetch_dispatcher_.reset();
+    out_result->status = actual_status;
+    out_result->result = actual_result;
+    out_result->response = actual_response;
+    if (!actual_response.blob_uuid.empty()) {
+      out_result->blob_data_handle =
+          blob_context->context()->GetBlobDataFromUUID(
+              actual_response.blob_uuid);
+    }
+    if (!quit.is_null())
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, quit);
+  }
+
+  ServiceWorkerFetchDispatcher::FetchCallback CreateResponseReceiver(
+      const base::Closure& quit,
+      ChromeBlobStorageContext* blob_context,
+      FetchResult* result) {
+    return base::Bind(
+        &self::ReceiveFetchResultOnIOThread, this, quit,
+        make_scoped_refptr<ChromeBlobStorageContext>(blob_context), result);
+  }
+
   void StopOnIOThread(const base::Closure& done,
                       ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(version_.get());
     version_->StopWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
  protected:
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
   scoped_refptr<ChromeBlobStorageContext> blob_context_;
@@ skipping 629 matching lines @@
   ASSERT_EQ(SERVICE_WORKER_OK, status);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
   // Restart the worker.
   StartWorker(SERVICE_WORKER_OK);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
 }
 
 }  // namespace content