[ServiceWorker] Set blob_size of ServiceWorkerFetchRequest as kuint64max when it is unknown.

content/browser/service_worker/service_worker_url_request_job.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_url_request_job.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 250 matching lines @@
     request->is_reload = PageTransitionCoreTypeIs(info->GetPageTransition(),
                                                   PAGE_TRANSITION_RELOAD);
   }
   return request.Pass();
 }
 
 bool ServiceWorkerURLRequestJob::CreateRequestBodyBlob(std::string* blob_uuid,
                                                        uint64* blob_size) {
   if (!body_.get() || !blob_storage_context_)
     return false;
-  const std::string uuid(base::GenerateGUID());
-  uint64 size = 0;
+
   std::vector<const ResourceRequestBody::Element*> resolved_elements;
   for (size_t i = 0; i < body_->elements()->size(); ++i) {
     const ResourceRequestBody::Element& element = (*body_->elements())[i];
     if (element.type() != ResourceRequestBody::Element::TYPE_BLOB) {
       resolved_elements.push_back(&element);
       continue;
     }
     scoped_ptr<storage::BlobDataHandle> handle =
         blob_storage_context_->GetBlobDataFromUUID(element.blob_uuid());
     if (handle->data()->items().empty())
       continue;
     for (size_t i = 0; i < handle->data()->items().size(); ++i) {
       const storage::BlobData::Item& item = handle->data()->items().at(i);
       DCHECK_NE(storage::BlobData::Item::TYPE_BLOB, item.type());
       resolved_elements.push_back(&item);
     }
   }
+
+  const std::string uuid(base::GenerateGUID());
+  uint64 total_size = 0;
   scoped_refptr<storage::BlobData> blob_data = new storage::BlobData(uuid);
   for (size_t i = 0; i < resolved_elements.size(); ++i) {
     const ResourceRequestBody::Element& element = *resolved_elements[i];
-    size += element.length();
+    if (total_size != kuint64max && element.length() != kuint64max)
+      total_size += element.length();
+    else
+      total_size = kuint64max;
     switch (element.type()) {
       case ResourceRequestBody::Element::TYPE_BYTES:
         blob_data->AppendData(element.bytes(), element.length());
         break;
       case ResourceRequestBody::Element::TYPE_FILE:
         blob_data->AppendFile(element.path(),
                               element.offset(),
                               element.length(),
                               element.expected_modification_time());
         break;
       case ResourceRequestBody::Element::TYPE_BLOB:
         // Blob elements should be resolved beforehand.
         NOTREACHED();
         break;
       case ResourceRequestBody::Element::TYPE_FILE_FILESYSTEM:
         blob_data->AppendFileSystemFile(element.filesystem_url(),
                                         element.offset(),
                                         element.length(),
                                         element.expected_modification_time());
         break;
       default:
         NOTIMPLEMENTED();
     }
   }
 
   request_body_blob_data_handle_ =
       blob_storage_context_->AddFinishedBlob(blob_data.get());
   *blob_uuid = uuid;
-  *blob_size = size;
+  *blob_size = total_size;
   return true;
 }
 
 void ServiceWorkerURLRequestJob::DidPrepareFetchEvent() {
   // TODO(shimazu): Set the timestamp to measure the time to launch SW
   // This is related to this (http://crbug.com/401389)
 }
 
 void ServiceWorkerURLRequestJob::DidDispatchFetchEvent(
     ServiceWorkerStatusCode status,
@@ skipping 79 matching lines @@
 void ServiceWorkerURLRequestJob::DeliverErrorResponse() {
   // TODO(falken): Print an error to the console of the ServiceWorker and of
   // the requesting page.
   CreateResponseHeader(500,
                        "Service Worker Response Error",
                        std::map<std::string, std::string>());
   CommitResponseHeader();
 }
 
 }  // namespace content