[ServiceWorkerCache] Clean up the service worker cache protobuf

Remove unnecessary values (cache size) and organize the
request/response metadata into separate messages.  This is cleaner in
the long run and now is the time to do it before the cache bit is
flipped and people start using it.

BUG=426878

Review URL: https://codereview.chromium.org/650993005

Cr-Commit-Position: refs/heads/master@{#301180}

4 files changed, 87 insertions, 86 deletions

diff --git a/content/browser/service_worker/service_worker_cache.cc b/content/browser/service_worker/service_worker_cache.cc
index 6146de7..d893f01 100644
--- a/content/browser/service_worker/service_worker_cache.cc
+++ b/content/browser/service_worker/service_worker_cache.cc
@@ -30,8 +30,8 @@ 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;
+typedef base::Callback<void(scoped_ptr<ServiceWorkerCacheMetadata>)>
+    MetadataCallback;
 
 enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY };
 
@@ -47,40 +47,39 @@ void NotReachedCompletionCallback(int rv) {
 }
 
 blink::WebServiceWorkerResponseType ProtoResponseTypeToWebResponseType(
-    ServiceWorkerRequestResponseHeaders_ResponseType response_type) {
+    ServiceWorkerCacheResponse::ResponseType response_type) {
   switch (response_type) {
-    case ServiceWorkerRequestResponseHeaders_ResponseType_BASIC_TYPE:
+    case ServiceWorkerCacheResponse::BASIC_TYPE:
       return blink::WebServiceWorkerResponseTypeBasic;
-    case ServiceWorkerRequestResponseHeaders_ResponseType_CORS_TYPE:
+    case ServiceWorkerCacheResponse::CORS_TYPE:
       return blink::WebServiceWorkerResponseTypeCORS;
-    case ServiceWorkerRequestResponseHeaders_ResponseType_DEFAULT_TYPE:
+    case ServiceWorkerCacheResponse::DEFAULT_TYPE:
       return blink::WebServiceWorkerResponseTypeDefault;
-    case ServiceWorkerRequestResponseHeaders_ResponseType_ERROR_TYPE:
+    case ServiceWorkerCacheResponse::ERROR_TYPE:
       return blink::WebServiceWorkerResponseTypeError;
-    case ServiceWorkerRequestResponseHeaders_ResponseType_OPAQUE_TYPE:
+    case ServiceWorkerCacheResponse::OPAQUE_TYPE:
       return blink::WebServiceWorkerResponseTypeOpaque;
   }
   NOTREACHED();
   return blink::WebServiceWorkerResponseTypeOpaque;
 }
 
-ServiceWorkerRequestResponseHeaders_ResponseType
-WebResponseTypeToProtoResponseType(
+ServiceWorkerCacheResponse::ResponseType WebResponseTypeToProtoResponseType(
     blink::WebServiceWorkerResponseType response_type) {
   switch (response_type) {
     case blink::WebServiceWorkerResponseTypeBasic:
-      return ServiceWorkerRequestResponseHeaders_ResponseType_BASIC_TYPE;
+      return ServiceWorkerCacheResponse::BASIC_TYPE;
     case blink::WebServiceWorkerResponseTypeCORS:
-      return ServiceWorkerRequestResponseHeaders_ResponseType_CORS_TYPE;
+      return ServiceWorkerCacheResponse::CORS_TYPE;
     case blink::WebServiceWorkerResponseTypeDefault:
-      return ServiceWorkerRequestResponseHeaders_ResponseType_DEFAULT_TYPE;
+      return ServiceWorkerCacheResponse::DEFAULT_TYPE;
     case blink::WebServiceWorkerResponseTypeError:
-      return ServiceWorkerRequestResponseHeaders_ResponseType_ERROR_TYPE;
+      return ServiceWorkerCacheResponse::ERROR_TYPE;
     case blink::WebServiceWorkerResponseTypeOpaque:
-      return ServiceWorkerRequestResponseHeaders_ResponseType_OPAQUE_TYPE;
+      return ServiceWorkerCacheResponse::OPAQUE_TYPE;
   }
   NOTREACHED();
-  return ServiceWorkerRequestResponseHeaders_ResponseType_OPAQUE_TYPE;
+  return ServiceWorkerCacheResponse::OPAQUE_TYPE;
 }
 
 struct ResponseReadContext {
@@ -262,12 +261,12 @@ void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv);
-void MatchDidReadHeaderData(
+void MatchDidReadMetadata(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
-    scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
+    scoped_ptr<ServiceWorkerCacheMetadata> headers);
 void MatchDidReadResponseBodyData(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
@@ -293,10 +292,10 @@ void DeleteDidOpenEntry(
 
 // Copy headers out of a cache entry and into a protobuf. The callback is
 // guaranteed to be run.
-void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback);
-void ReadHeadersDidReadHeaderData(
+void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback);
+void ReadMetadataDidReadMetadata(
     disk_cache::Entry* entry,
-    const HeadersCallback& callback,
+    const MetadataCallback& callback,
     const scoped_refptr<net::IOBufferWithSize>& buffer,
     int rv);
 
@@ -316,34 +315,34 @@ void PutDidCreateEntry(scoped_ptr<PutContext> put_context, int rv) {
 
   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));
+  ServiceWorkerCacheMetadata metadata;
+  ServiceWorkerCacheRequest* request_metadata = metadata.mutable_request();
+  request_metadata->set_method(put_context->request->method);
   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();
+    ServiceWorkerCacheHeaderMap* header_map = request_metadata->add_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
+  ServiceWorkerCacheResponse* response_metadata = metadata.mutable_response();
+  response_metadata->set_status_code(put_context->response->status_code);
+  response_metadata->set_status_text(put_context->response->status_text);
+  response_metadata->set_response_type(
+      WebResponseTypeToProtoResponseType(put_context->response->response_type));
   for (ServiceWorkerHeaderMap::const_iterator it =
            put_context->response->headers.begin();
        it != put_context->response->headers.end();
        ++it) {
-    ServiceWorkerRequestResponseHeaders::HeaderMap* header_map =
-        headers.add_response_headers();
+    ServiceWorkerCacheHeaderMap* header_map = response_metadata->add_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
   scoped_ptr<std::string> serialized(new std::string());
-  if (!headers.SerializeToString(serialized.get())) {
+  if (!metadata.SerializeToString(serialized.get())) {
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
                               scoped_ptr<storage::BlobDataHandle>());
@@ -466,13 +465,13 @@ void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
   // Copy the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
-  HeadersCallback headers_callback = base::Bind(MatchDidReadHeaderData,
-                                                base::Passed(request.Pass()),
-                                                callback,
-                                                blob_storage,
-                                                base::Passed(entry.Pass()));
+  MetadataCallback headers_callback = base::Bind(MatchDidReadMetadata,
+                                                 base::Passed(request.Pass()),
+                                                 callback,
+                                                 blob_storage,
+                                                 base::Passed(entry.Pass()));
 
-  ReadHeaders(tmp_entry_ptr, headers_callback);
+  ReadMetadata(tmp_entry_ptr, headers_callback);
 }
 
 bool VaryMatches(const ServiceWorkerHeaderMap& request,
@@ -511,13 +510,13 @@ bool VaryMatches(const ServiceWorkerHeaderMap& request,
   return true;
 }
 
-void MatchDidReadHeaderData(
+void MatchDidReadMetadata(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
-    scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
-  if (!headers) {
+    scoped_ptr<ServiceWorkerCacheMetadata> metadata) {
+  if (!metadata) {
     callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
@@ -526,23 +525,21 @@ void MatchDidReadHeaderData(
 
   scoped_ptr<ServiceWorkerResponse> response(new ServiceWorkerResponse(
       request->url,
-      headers->status_code(),
-      headers->status_text(),
-      ProtoResponseTypeToWebResponseType(headers->response_type()),
+      metadata->response().status_code(),
+      metadata->response().status_text(),
+      ProtoResponseTypeToWebResponseType(metadata->response().response_type()),
       ServiceWorkerHeaderMap(),
       "",
       0));
 
-  for (int i = 0; i < headers->response_headers_size(); ++i) {
-    const ServiceWorkerRequestResponseHeaders::HeaderMap header =
-        headers->response_headers(i);
+  for (int i = 0; i < metadata->response().headers_size(); ++i) {
+    const ServiceWorkerCacheHeaderMap header = metadata->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 =
-        headers->request_headers(i);
+  for (int i = 0; i < metadata->request().headers_size(); ++i) {
+    const ServiceWorkerCacheHeaderMap header = metadata->request().headers(i);
     cached_request_headers[header.name()] = header.value();
   }
 
@@ -705,14 +702,14 @@ void DeleteDidOpenEntry(
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
-void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback) {
+void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback) {
   DCHECK(entry);
 
   scoped_refptr<net::IOBufferWithSize> buffer(
       new net::IOBufferWithSize(entry->GetDataSize(INDEX_HEADERS)));
 
   net::CompletionCallback read_header_callback =
-      base::Bind(ReadHeadersDidReadHeaderData, entry, callback, buffer);
+      base::Bind(ReadMetadataDidReadMetadata, entry, callback, buffer);
 
   int read_rv = entry->ReadData(
       INDEX_HEADERS, 0, buffer.get(), buffer->size(), read_header_callback);
@@ -721,25 +718,25 @@ void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback) {
     read_header_callback.Run(read_rv);
 }
 
-void ReadHeadersDidReadHeaderData(
+void ReadMetadataDidReadMetadata(
     disk_cache::Entry* entry,
-    const HeadersCallback& callback,
+    const MetadataCallback& callback,
     const scoped_refptr<net::IOBufferWithSize>& buffer,
     int rv) {
   if (rv != buffer->size()) {
-    callback.Run(scoped_ptr<ServiceWorkerRequestResponseHeaders>());
+    callback.Run(scoped_ptr<ServiceWorkerCacheMetadata>());
     return;
   }
 
-  scoped_ptr<ServiceWorkerRequestResponseHeaders> headers(
-      new ServiceWorkerRequestResponseHeaders());
+  scoped_ptr<ServiceWorkerCacheMetadata> metadata(
+      new ServiceWorkerCacheMetadata());
 
-  if (!headers->ParseFromArray(buffer->data(), buffer->size())) {
-    callback.Run(scoped_ptr<ServiceWorkerRequestResponseHeaders>());
+  if (!metadata->ParseFromArray(buffer->data(), buffer->size())) {
+    callback.Run(scoped_ptr<ServiceWorkerCacheMetadata>());
     return;
   }
 
-  callback.Run(headers.Pass());
+  callback.Run(metadata.Pass());
 }
 
 void CreateBackendDidCreate(const ServiceWorkerCache::ErrorCallback& callback,
@@ -1106,22 +1103,22 @@ void ServiceWorkerCache::KeysProcessNextEntry(
     return;
   }
 
-  ReadHeaders(
+  ReadMetadata(
       *iter,
-      base::Bind(KeysDidReadHeaders, base::Passed(keys_context.Pass()), iter));
+      base::Bind(KeysDidReadMetadata, base::Passed(keys_context.Pass()), iter));
 }
 
 // static
-void ServiceWorkerCache::KeysDidReadHeaders(
+void ServiceWorkerCache::KeysDidReadMetadata(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter,
-    scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
+    scoped_ptr<ServiceWorkerCacheMetadata> metadata) {
   disk_cache::Entry* entry = *iter;
 
-  if (headers) {
+  if (metadata) {
     keys_context->out_keys->push_back(
         ServiceWorkerFetchRequest(GURL(entry->GetKey()),
-                                  headers->method(),
+                                  metadata->request().method(),
                                   ServiceWorkerHeaderMap(),
                                   GURL(),
                                   false));
@@ -1129,9 +1126,8 @@ void ServiceWorkerCache::KeysDidReadHeaders(
     ServiceWorkerHeaderMap& req_headers =
         keys_context->out_keys->back().headers;
 
-    for (int i = 0; i < headers->request_headers_size(); ++i) {
-      const ServiceWorkerRequestResponseHeaders::HeaderMap header =
-          headers->request_headers(i);
+    for (int i = 0; i < metadata->request().headers_size(); ++i) {
+      const ServiceWorkerCacheHeaderMap header = metadata->request().headers(i);
       req_headers.insert(std::make_pair(header.name(), header.value()));
     }
   } else {
diff --git a/content/browser/service_worker/service_worker_cache.h b/content/browser/service_worker/service_worker_cache.h
index ae9b7f3..ee170e6 100644
--- a/content/browser/service_worker/service_worker_cache.h
+++ b/content/browser/service_worker/service_worker_cache.h
@@ -27,7 +27,7 @@ class QuotaManagerProxy;
 
 namespace content {
 class ChromeBlobStorageContext;
-class ServiceWorkerRequestResponseHeaders;
+class ServiceWorkerCacheMetadata;
 
 // TODO(jkarlin): Unload cache backend from memory once the cache object is no
 // longer referenced in javascript.
@@ -127,10 +127,10 @@ class CONTENT_EXPORT ServiceWorkerCache
                                    int rv);
   static void KeysProcessNextEntry(scoped_ptr<KeysContext> keys_context,
                                    const Entries::iterator& iter);
-  static void KeysDidReadHeaders(
+  static void KeysDidReadMetadata(
       scoped_ptr<KeysContext> keys_context,
       const Entries::iterator& iter,
-      scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
+      scoped_ptr<ServiceWorkerCacheMetadata> metadata);
 
   // Loads the backend and calls the callback with the result (true for
   // success). The callback will always be called.
diff --git a/content/browser/service_worker/service_worker_cache.proto b/content/browser/service_worker/service_worker_cache.proto
index 000eadc..1ba40de1 100644
--- a/content/browser/service_worker/service_worker_cache.proto
+++ b/content/browser/service_worker/service_worker_cache.proto
@@ -11,19 +11,22 @@ package content;
 message ServiceWorkerCacheStorageIndex {
   message Cache {
     required string name = 1;
-    optional int32 DEPRECATED_size = 2;
-    optional int64 size = 3;
   }
   repeated Cache cache = 1;
   optional string origin = 2;
 }
 
-message ServiceWorkerRequestResponseHeaders {
-  message HeaderMap {
-    required string name = 1;
-    required string value = 2;
-  }
+message ServiceWorkerCacheHeaderMap {
+  required string name = 1;
+  required string value = 2;
+}
+
+message ServiceWorkerCacheRequest {
+  required string method = 1;
+  repeated ServiceWorkerCacheHeaderMap headers = 2;
+}
 
+message ServiceWorkerCacheResponse {
   enum ResponseType {
     BASIC_TYPE = 0;
     CORS_TYPE = 1;
@@ -32,10 +35,13 @@ message ServiceWorkerRequestResponseHeaders {
     OPAQUE_TYPE = 4;
   }
 
-  required string method = 1;
-  required int32 status_code = 2;
-  required string status_text = 3;
-  repeated HeaderMap request_headers = 4;
-  repeated HeaderMap response_headers = 5;
-  required ResponseType response_type = 6;
+  required int32 status_code = 1;
+  required string status_text = 2;
+  required ResponseType response_type = 3;
+  repeated ServiceWorkerCacheHeaderMap headers = 4;
 }
+
+message ServiceWorkerCacheMetadata {
+  required ServiceWorkerCacheRequest request = 1;
+  required ServiceWorkerCacheResponse response = 2;
+}
\ No newline at end of file
diff --git a/content/browser/service_worker/service_worker_cache_storage.cc b/content/browser/service_worker/service_worker_cache_storage.cc
index b16d54c..964e13b 100644
--- a/content/browser/service_worker/service_worker_cache_storage.cc
+++ b/content/browser/service_worker/service_worker_cache_storage.cc
@@ -248,7 +248,6 @@ class ServiceWorkerCacheStorage::SimpleCacheLoader
     for (size_t i = 0u, max = cache_names.size(); i < max; ++i) {
       ServiceWorkerCacheStorageIndex::Cache* index_cache = index.add_cache();
       index_cache->set_name(cache_names[i]);
-      index_cache->set_size(0);  // TODO(jkarlin): Make this real.
     }
 
     std::string serialized;