Start of Chrome-side plumbing for ServiceWorker fetch

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/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
@@ skipping 27 matching lines @@
 
 void RunOnIOThread(const base::Closure& closure) {
   base::RunLoop run_loop;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&RunAndQuit, closure, run_loop.QuitClosure(),
                  base::MessageLoopProxy::current()));
   run_loop.Run();
 }
 
+void ReceiveFetchResult(BrowserThread::ID run_quit_thread,
+                        const base::Closure& quit,
+                        ServiceWorkerStatusCode* out_status,
+                        ServiceWorkerFetchResponse* out_response,
+                        ServiceWorkerStatusCode actual_status,
+                        const ServiceWorkerFetchResponse& actual_response) {
+  *out_status = actual_status;
+  *out_response = actual_response;
+  if (!quit.is_null())
+    BrowserThread::PostTask(run_quit_thread, FROM_HERE, quit);
+}
+
+ServiceWorkerVersion::FetchCallback CreateFetchResponseReceiver(
+    BrowserThread::ID run_quit_thread,
+    const base::Closure& quit,
+    ServiceWorkerStatusCode* out_status,
+    ServiceWorkerFetchResponse* out_response) {
+  return base::Bind(
+      &ReceiveFetchResult, run_quit_thread, quit, out_status, out_response);
+}
+
+

[kinuko, 2014/02/19 07:18:00]

nit: extra empty line

[falken, 2014/02/19 07:30:01]

Done.

 }  // namespace
 
 class ServiceWorkerBrowserTest : public ContentBrowserTest {
  protected:
   typedef ServiceWorkerBrowserTest self;
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(switches::kEnableServiceWorker);
   }
 
@@ skipping 166 matching lines @@
     AssociateRendererProcessToWorker(version_->embedded_worker());
   }
 
   void StartOnIOThread(const base::Closure& done,
                        ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->StartWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void InstallOnIOThread(const base::Closure& done,
-                        ServiceWorkerStatusCode* result) {
+                         ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->DispatchInstallEvent(
         -1, CreateReceiver(BrowserThread::UI, done, result));
   }
 
+  void FetchOnIOThread(const base::Closure& done,
+                       ServiceWorkerStatusCode* result,
+                       ServiceWorkerFetchResponse* message) {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    ServiceWorkerFetchRequest request(
+        embedded_test_server()->GetURL("/service_worker/empty.html"),
+        "GET",
+        std::map<std::string, std::string>());
+    version_->DispatchFetchEvent(
+        request,
+        CreateFetchResponseReceiver(BrowserThread::UI, done, result, message));
+  }
+
+
   void StopOnIOThread(const base::Closure& done,
                       ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(version_);
     version_->StopWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
  protected:
   int64 next_registration_id_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
@@ skipping 68 matching lines @@
   InstallTestHelper("/service_worker/worker_install_fulfilled.js");
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Rejected) {
   // TODO(kinuko): This should also report back an error, but we
   // don't have plumbing for it yet.
   InstallTestHelper("/service_worker/worker_install_rejected.js");
 }
 
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, Fetch) {
+  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
+                           "/service_worker/worker.js"));
+
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+  ServiceWorkerFetchResponse response;
+  base::RunLoop fetch_run_loop;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&self::FetchOnIOThread, this,
+                                     fetch_run_loop.QuitClosure(),
+                                     &status, &response));
+  fetch_run_loop.Run();
+  ASSERT_EQ(SERVICE_WORKER_OK, status);
+  ASSERT_EQ(200, response.status_code);
+  ASSERT_EQ("OK", response.status_text);
+  ASSERT_EQ("GET", response.method);
+  std::map<std::string, std::string> expected_headers;
+  ASSERT_EQ(expected_headers, response.headers);
+}
+
 }  // namespace content