Support WebServiceWorkerResponseType in ServiceWorkerCache.

content/browser/service_worker/service_worker_cache_unittest.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 "content/browser/service_worker/service_worker_cache.h"
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
@@ skipping 87 matching lines @@
     for (int i = 0; i < 100; ++i)
       expected_blob_data_ += kTestData;
 
     scoped_refptr<storage::BlobData> blob_data(
         new storage::BlobData("blob-id:myblob"));
     blob_data->AppendData(expected_blob_data_);
 
     blob_handle_ =
         blob_storage_context->context()->AddFinishedBlob(blob_data.get());
 
-    body_response_ = ServiceWorkerResponse(GURL("http://example.com/body.html"),
-                                           200,
-                                           "OK",
-                                           headers,
-                                           blob_handle_->uuid());
+    body_response_ =
+        ServiceWorkerResponse(GURL("http://example.com/body.html"),
+                              200,
+                              "OK",
+                              blink::WebServiceWorkerResponseTypeDefault,
+                              headers,
+                              blob_handle_->uuid());
 
-    no_body_response_ = ServiceWorkerResponse(
-        GURL("http://example.com/no_body.html"), 200, "OK", headers, "");
+    no_body_response_ =
+        ServiceWorkerResponse(GURL("http://example.com/no_body.html"),
+                              200,
+                              "OK",
+                              blink::WebServiceWorkerResponseTypeDefault,
+                              headers,
+                              "");
   }
 
   scoped_ptr<ServiceWorkerFetchRequest> CopyFetchRequest(
       const ServiceWorkerFetchRequest& request) {
     return make_scoped_ptr(new ServiceWorkerFetchRequest(request.url,
                                                          request.method,
                                                          request.headers,
                                                          request.referrer,
                                                          request.is_reload));
   }
 
   scoped_ptr<ServiceWorkerResponse> CopyFetchResponse(
       const ServiceWorkerResponse& response) {
-    return make_scoped_ptr(new ServiceWorkerResponse(response.url,
-                                                     response.status_code,
-                                                     response.status_text,
-                                                     response.headers,
-                                                     response.blob_uuid));
+    scoped_ptr<ServiceWorkerResponse> sw_response(
+        new ServiceWorkerResponse(response.url,
+                                  response.status_code,
+                                  response.status_text,
+                                  response.response_type,
+                                  response.headers,
+                                  response.blob_uuid));
+    return sw_response.Pass();
   }
 
   bool Put(const ServiceWorkerFetchRequest& request,
            const ServiceWorkerResponse& response) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Put(CopyFetchRequest(request),
                 CopyFetchResponse(response),
                 base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback,
                            base::Unretained(this),
@@ skipping 88 matching lines @@
     for (int i = 0, max = callback_strings_.size(); i < max; ++i)
       found_set.insert(callback_strings_[i]);
 
     for (int i = 0, max = expected_keys.size(); i < max; ++i) {
       if (found_set.find(expected_keys[i]) == found_set.end())
         return false;
     }
     return true;
   }
 
+  bool TestResponseType(blink::WebServiceWorkerResponseType response_type) {
+    body_response_.response_type = response_type;
+    EXPECT_TRUE(Put(body_request_, body_response_));
+    EXPECT_TRUE(Match(body_request_));
+    EXPECT_TRUE(Delete(body_request_));
+    return response_type == callback_response_->response_type;
+  }
+
   virtual bool MemoryOnly() { return false; }
 
  protected:
   TestBrowserContext browser_context_;
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<net::URLRequestJobFactoryImpl> url_request_job_factory_;
   storage::BlobStorageContext* blob_storage_context_;
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<ServiceWorkerCache> cache_;
@@ skipping 160 matching lines @@
   EXPECT_TRUE(Delete(body_request_));
   EXPECT_TRUE(Keys());
   EXPECT_EQ(1u, callback_strings_.size());
   std::vector<std::string> expected_key;
   expected_key.push_back(no_body_request_.url.spec());
   EXPECT_TRUE(VerifyKeys(expected_key));
 }
 
 // TODO(jkarlin): Once SimpleCache is working bug-free on Windows reenable these
 // tests. In the meanwhile we know that Windows operations will be a little
-// flaky (though not crashy). See https://crbug.com/409109
+// flaky (though not crashy). See https://crbug.com/409109 and
+// https://crbug.com/416940.
 #ifndef OS_WIN
 TEST_P(ServiceWorkerCacheTestP, DeleteNoBody) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
   EXPECT_TRUE(Delete(no_body_request_));
   EXPECT_FALSE(Match(no_body_request_));
   EXPECT_FALSE(Delete(no_body_request_));
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
   EXPECT_TRUE(Delete(no_body_request_));
@@ skipping 20 matching lines @@
 }
 
 TEST_P(ServiceWorkerCacheTestP, QuickStressBody) {
   for (int i = 0; i < 100; ++i) {
     ASSERT_FALSE(Match(body_request_));
     ASSERT_TRUE(Put(body_request_, body_response_));
     ASSERT_TRUE(Match(body_request_));
     ASSERT_TRUE(Delete(body_request_));
   }
 }
+
+TEST_P(ServiceWorkerCacheTestP, PutResponseType) {
+  EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeBasic));
+  EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeCORS));
+  EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeDefault));
+  EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeError));
+  EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeOpaque));
+}
 #endif  // OS_WIN
 
 TEST_F(ServiceWorkerCacheTest, CaselessServiceWorkerResponseHeaders) {
   // ServiceWorkerCache depends on ServiceWorkerResponse having caseless
   // headers so that it can quickly lookup vary headers.
-  ServiceWorkerResponse response(
-      GURL("http://www.example.com"), 200, "OK", ServiceWorkerHeaderMap(), "");
+  ServiceWorkerResponse response(GURL("http://www.example.com"),
+                                 200,
+                                 "OK",
+                                 blink::WebServiceWorkerResponseTypeDefault,
+                                 ServiceWorkerHeaderMap(),
+                                 "");
   response.headers["content-type"] = "foo";
   response.headers["Content-Type"] = "bar";
   EXPECT_EQ("bar", response.headers["content-type"]);
 }
 
 TEST_F(ServiceWorkerCacheTest, CaselessServiceWorkerFetchRequestHeaders) {
   // ServiceWorkerCache depends on ServiceWorkerFetchRequest having caseless
   // headers so that it can quickly lookup vary headers.
   ServiceWorkerFetchRequest request(GURL("http://www.example.com"),
                                          "GET",
                                          ServiceWorkerHeaderMap(),
                                          GURL(""),
                                          false);
   request.headers["content-type"] = "foo";
   request.headers["Content-Type"] = "bar";
   EXPECT_EQ("bar", request.headers["content-type"]);
 }
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content