ServiceWorker browser test fix

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
@@ skipping 21 matching lines @@
 #include "webkit/common/blob/blob_data.h"
 
 namespace content {
 
 namespace {
 
 struct FetchResult {
   ServiceWorkerStatusCode status;
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
+  scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle;
 };
 
 void RunAndQuit(const base::Closure& closure,
                 const base::Closure& quit,
                 base::MessageLoopProxy* original_message_loop) {
   closure.Run();
   original_message_loop->PostTask(FROM_HERE, quit);
 }
 
 void RunOnIOThread(const base::Closure& closure) {
@@ skipping 17 matching lines @@
                           FROM_HERE,
                           base::Bind(closure, quit_on_original_thread));
   run_loop.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 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) {
   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);
 }
 
 ServiceWorkerVersion::FetchCallback CreateResponseReceiver(
     BrowserThread::ID run_quit_thread,
     const base::Closure& quit,
+    ChromeBlobStorageContext* blob_context,
     FetchResult* result) {
-  return base::Bind(&ReceiveFetchResult, run_quit_thread, quit, result);
+  return base::Bind(&ReceiveFetchResult, run_quit_thread, quit,
+                    make_scoped_refptr<ChromeBlobStorageContext>(blob_context),
+                    result);
 }
 
 void ReadResponseBody(std::string* body,
-                      scoped_refptr<ChromeBlobStorageContext> context,
-                      std::string blob_uuid) {
-  scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle =
-      context->context()->GetBlobDataFromUUID(blob_uuid);
+                      webkit_blob::BlobDataHandle* blob_data_handle) {
+  ASSERT_TRUE(blob_data_handle);
   ASSERT_EQ(1U, blob_data_handle->data()->items().size());
   *body = std::string(blob_data_handle->data()->items()[0].bytes(),
                       blob_data_handle->data()->items()[0].length());
 }
 
 }  // namespace
 
 class ServiceWorkerBrowserTest : public ContentBrowserTest {
  protected:
   typedef ServiceWorkerBrowserTest self;
@@ skipping 181 matching lines @@
     base::RunLoop run_loop;
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(
             &self::ActivateOnIOThread, this, run_loop.QuitClosure(), &status));
     run_loop.Run();
     ASSERT_EQ(expected_status, status);
   }
 
-  void FetchOnRegisteredWorker(ServiceWorkerFetchEventResult* result,
-                               ServiceWorkerResponse* response) {
+  void FetchOnRegisteredWorker(
+      ServiceWorkerFetchEventResult* result,
+      ServiceWorkerResponse* response,
+      scoped_ptr<webkit_blob::BlobDataHandle>* blob_data_handle) {
+    blob_context_ = ChromeBlobStorageContext::GetFor(
+        shell()->web_contents()->GetBrowserContext());
     FetchResult fetch_result;
     fetch_result.status = SERVICE_WORKER_ERROR_FAILED;
     base::RunLoop fetch_run_loop;
     BrowserThread::PostTask(BrowserThread::IO,
                             FROM_HERE,
                             base::Bind(&self::FetchOnIOThread,
                                        this,
                                        fetch_run_loop.QuitClosure(),
                                        &fetch_result));
     fetch_run_loop.Run();
     *result = fetch_result.result;
     *response = fetch_result.response;
+    *blob_data_handle = fetch_result.blob_data_handle.Pass();
     ASSERT_EQ(SERVICE_WORKER_OK, fetch_result.status);
   }
 
-  void FetchTestHelper(const std::string& worker_url,
-                       ServiceWorkerFetchEventResult* result,
-                       ServiceWorkerResponse* response) {
+  void FetchTestHelper(
+      const std::string& worker_url,
+      ServiceWorkerFetchEventResult* result,
+      ServiceWorkerResponse* response,
+      scoped_ptr<webkit_blob::BlobDataHandle>* blob_data_handle) {
     RunOnIOThread(
         base::Bind(&self::SetUpRegistrationOnIOThread, this, worker_url));
-
-    FetchOnRegisteredWorker(result, response);
+    FetchOnRegisteredWorker(result, response, blob_data_handle);
   }
 
   void SetUpRegistrationOnIOThread(const std::string& worker_url) {
     registration_ = new ServiceWorkerRegistration(
         embedded_test_server()->GetURL("/*"),
         embedded_test_server()->GetURL(worker_url),
         wrapper()->context()->storage()->NewRegistrationId(),
         wrapper()->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(
         registration_,
@@ skipping 24 matching lines @@
   }
 
   void FetchOnIOThread(const base::Closure& done, FetchResult* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     ServiceWorkerFetchRequest request(
         embedded_test_server()->GetURL("/service_worker/empty.html"),
         "GET",
         std::map<std::string, std::string>());
     version_->SetStatus(ServiceWorkerVersion::ACTIVE);
     version_->DispatchFetchEvent(
-        request, CreateResponseReceiver(BrowserThread::UI, done, result));
+        request, CreateResponseReceiver(BrowserThread::UI, done,
+                                        blob_context_, result));
   }
 
   void StopOnIOThread(const base::Closure& done,
                       ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(version_);
     version_->StopWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void SyncEventOnIOThread(const base::Closure& done,
                            ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->SetStatus(ServiceWorkerVersion::ACTIVE);
     version_->DispatchSyncEvent(
         CreateReceiver(BrowserThread::UI, done, result));
   }
 
  protected:
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
+  scoped_refptr<ChromeBlobStorageContext> blob_context_;
 };
 
 IN_PROC_BROWSER_TEST_F(EmbeddedWorkerBrowserTest, StartAndStop) {
   // Start a worker and wait until OnStarted() is called.
   base::RunLoop start_run_loop;
   done_closure_ = start_run_loop.QuitClosure();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&self::StartOnIOThread, this));
   start_run_loop.Run();
 
@@ skipping 72 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Rejected) {
   InstallTestHelper("/service_worker/worker_install_rejected.js",
                     SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Response) {
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
-  FetchTestHelper("/service_worker/fetch_event.js", &result, &response);
+  scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle;
+  FetchTestHelper("/service_worker/fetch_event.js",
+                  &result, &response, &blob_data_handle);
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(301, response.status_code);
   EXPECT_EQ("Moved Permanently", response.status_text);
   std::map<std::string, std::string> expected_headers;
   expected_headers["Content-Language"] = "fi";
   expected_headers["Content-Type"] = "text/html; charset=UTF-8";
   EXPECT_EQ(expected_headers, response.headers);
 
-  scoped_refptr<ChromeBlobStorageContext> context =
-      ChromeBlobStorageContext::GetFor(
-          shell()->web_contents()->GetBrowserContext());
   std::string body;
   RunOnIOThread(
-      base::Bind(&ReadResponseBody, &body, context, response.blob_uuid));
+      base::Bind(&ReadResponseBody,
+                 &body, base::Owned(blob_data_handle.release())));
   EXPECT_EQ("This resource is gone. Gone, gone, gone.", body);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        SyncAbortedWithoutFlag) {
   RunOnIOThread(base::Bind(
       &self::SetUpRegistrationOnIOThread, this, "/service_worker/sync.js"));
 
   // Run the sync event.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
   base::RunLoop sync_run_loop;
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&self::SyncEventOnIOThread,
                                      this,
                                      sync_run_loop.QuitClosure(),
                                      &status));
   sync_run_loop.Run();
   ASSERT_EQ(SERVICE_WORKER_ERROR_ABORT, status);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, SyncEventHandled) {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(switches::kEnableServiceWorkerSync);
 
   RunOnIOThread(base::Bind(
       &self::SetUpRegistrationOnIOThread, this, "/service_worker/sync.js"));
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
-
+  scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle;
   // Should 404 before sync event.
-  FetchOnRegisteredWorker(&result, &response);
+  FetchOnRegisteredWorker(&result, &response, &blob_data_handle);
   EXPECT_EQ(404, response.status_code);
 
   // Run the sync event.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
   base::RunLoop sync_run_loop;
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&self::SyncEventOnIOThread,
                                      this,
                                      sync_run_loop.QuitClosure(),
                                      &status));
   sync_run_loop.Run();
   ASSERT_EQ(SERVICE_WORKER_OK, status);
 
   // Should 200 after sync event.
-  FetchOnRegisteredWorker(&result, &response);
+  FetchOnRegisteredWorker(&result, &response, &blob_data_handle);
   EXPECT_EQ(200, response.status_code);
 }
 
 class ServiceWorkerBlackBoxBrowserTest : public ServiceWorkerBrowserTest {
  public:
   typedef ServiceWorkerBlackBoxBrowserTest self;
 
   static void ExpectResultAndRun(bool expected,
                                  const base::Closure& continuation,
                                  bool actual) {
@@ skipping 123 matching lines @@
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::FindRegistrationOnIO,
                    this,
                    embedded_test_server()->GetURL("/service_worker/empty.html"),
                    &status,
                    &script_url));
     EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND, status);
   }
 }
 
 }  // namespace content