Support WebServiceWorkerResponseType in ServiceWorkerCache.

content/browser/service_worker/service_worker_cache.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 <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
+#include "third_party/WebKit/public/platform/WebServiceWorkerResponseType.h"
 
 namespace content {
 
 namespace {
 
 typedef scoped_ptr<disk_cache::Backend> ScopedBackendPtr;
 typedef base::Callback<void(bool)> BoolCallback;
 typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
     EntryBoolCallback;
 typedef base::Callback<void(scoped_ptr<ServiceWorkerRequestResponseHeaders>)>
     HeadersCallback;
 
 enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY };
 
 // The maximum size of an individual cache. Ultimately cache size is controlled
 // per-origin.
 const int kMaxCacheBytes = 512 * 1024 * 1024;
 
 // Buffer size for cache and blob reading/writing.
 const int kBufferSize = 1024 * 512;
 
+blink::WebServiceWorkerResponseType ProtoResponseTypeToWebResponseType(

[jochen (gone - plz use gerrit), 2014/10/02 07:35:28]

can you use the assert matching enums macro and just static_cast<> the values
back and forth?

[jkarlin, 2014/10/02 13:34:29]

After chat discussion with jochen@ it was clarified that since one enum is a
protobuf enum the matching enums macros is unnecessary and the cl can land as
is.

+    ServiceWorkerRequestResponseHeaders_ResponseType response_type) {
+  switch (response_type) {
+    case ServiceWorkerRequestResponseHeaders_ResponseType_BASIC_TYPE:
+      return blink::WebServiceWorkerResponseTypeBasic;
+    case ServiceWorkerRequestResponseHeaders_ResponseType_CORS_TYPE:
+      return blink::WebServiceWorkerResponseTypeCORS;
+    case ServiceWorkerRequestResponseHeaders_ResponseType_DEFAULT_TYPE:
+      return blink::WebServiceWorkerResponseTypeDefault;
+    case ServiceWorkerRequestResponseHeaders_ResponseType_ERROR_TYPE:
+      return blink::WebServiceWorkerResponseTypeError;
+    case ServiceWorkerRequestResponseHeaders_ResponseType_OPAQUE_TYPE:
+      return blink::WebServiceWorkerResponseTypeOpaque;
+  }
+  NOTREACHED();
+  return blink::WebServiceWorkerResponseTypeOpaque;
+}
+
+ServiceWorkerRequestResponseHeaders_ResponseType
+WebResponseTypeToProtoResponseType(
+    blink::WebServiceWorkerResponseType response_type) {
+  switch (response_type) {
+    case blink::WebServiceWorkerResponseTypeBasic:
+      return ServiceWorkerRequestResponseHeaders_ResponseType_BASIC_TYPE;
+    case blink::WebServiceWorkerResponseTypeCORS:
+      return ServiceWorkerRequestResponseHeaders_ResponseType_CORS_TYPE;
+    case blink::WebServiceWorkerResponseTypeDefault:
+      return ServiceWorkerRequestResponseHeaders_ResponseType_DEFAULT_TYPE;
+    case blink::WebServiceWorkerResponseTypeError:
+      return ServiceWorkerRequestResponseHeaders_ResponseType_ERROR_TYPE;
+    case blink::WebServiceWorkerResponseTypeOpaque:
+      return ServiceWorkerRequestResponseHeaders_ResponseType_OPAQUE_TYPE;
+  }
+  NOTREACHED();
+  return ServiceWorkerRequestResponseHeaders_ResponseType_OPAQUE_TYPE;
+}
+
 struct ResponseReadContext {
   ResponseReadContext(scoped_refptr<net::IOBufferWithSize> buff,
                       scoped_refptr<storage::BlobData> blob)
       : buffer(buff), blob_data(blob), total_bytes_read(0) {}
 
   scoped_refptr<net::IOBufferWithSize> buffer;
   scoped_refptr<storage::BlobData> blob_data;
   int total_bytes_read;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseReadContext);
@@ skipping 205 matching lines @@
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeExists,
                               scoped_ptr<ServiceWorkerResponse>(),
                               scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   DCHECK(put_context->cache_entry);
 
   ServiceWorkerRequestResponseHeaders headers;
   headers.set_method(put_context->request->method);
-
   headers.set_status_code(put_context->response->status_code);
   headers.set_status_text(put_context->response->status_text);
+  headers.set_response_type(
+      WebResponseTypeToProtoResponseType(put_context->response->response_type));
   for (ServiceWorkerHeaderMap::const_iterator it =
            put_context->request->headers.begin();
        it != put_context->request->headers.end();
        ++it) {
     ServiceWorkerRequestResponseHeaders::HeaderMap* header_map =
         headers.add_request_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
@@ skipping 161 matching lines @@
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
   if (!headers) {
     callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  scoped_ptr<ServiceWorkerResponse> response(
-      new ServiceWorkerResponse(request->url,
-                                headers->status_code(),
-                                headers->status_text(),
-                                ServiceWorkerHeaderMap(),
-                                ""));
+  scoped_ptr<ServiceWorkerResponse> response(new ServiceWorkerResponse(
+      request->url,
+      headers->status_code(),
+      headers->status_text(),
+      ProtoResponseTypeToWebResponseType(headers->response_type()),
+      ServiceWorkerHeaderMap(),
+      ""));
 
   for (int i = 0; i < headers->response_headers_size(); ++i) {
     const ServiceWorkerRequestResponseHeaders::HeaderMap header =
         headers->response_headers(i);
     response->headers.insert(std::make_pair(header.name(), header.value()));
   }
 
   ServiceWorkerHeaderMap cached_request_headers;
   for (int i = 0; i < headers->request_headers_size(); ++i) {
     const ServiceWorkerRequestResponseHeaders::HeaderMap header =
@@ skipping 588 matching lines @@
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 }  // namespace content