Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

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 14 matching lines @@
 #include "webkit/browser/blob/blob_data_handle.h"
 #include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/browser/blob/blob_url_request_job_factory.h"
 
 namespace content {
 
 ServiceWorkerURLRequestJob::ServiceWorkerURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
-    base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
+    base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     scoped_refptr<ResourceRequestBody> body)
     : net::URLRequestJob(request, network_delegate),
       provider_host_(provider_host),
       response_type_(NOT_DETERMINED),
       is_started_(false),
       blob_storage_context_(blob_storage_context),
       body_(body),
       weak_factory_(this) {
 }
 
@@ skipping 222 matching lines @@
     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<webkit_blob::BlobDataHandle> handle =
+    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 webkit_blob::BlobData::Item& item = handle->data()->items().at(i);
-      DCHECK_NE(webkit_blob::BlobData::Item::TYPE_BLOB, item.type());
+      const storage::BlobData::Item& item = handle->data()->items().at(i);
+      DCHECK_NE(storage::BlobData::Item::TYPE_BLOB, item.type());
       resolved_elements.push_back(&item);
     }
   }
-  scoped_refptr<webkit_blob::BlobData> blob_data =
-      new webkit_blob::BlobData(uuid);
+  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();
     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(),
@@ skipping 49 matching lines @@
     response_type_ = FALLBACK_TO_NETWORK;
     NotifyRestartRequired();
     return;
   }
 
   // We should have a response now.
   DCHECK_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, fetch_result);
 
   // Set up a request for reading the blob.
   if (!response.blob_uuid.empty() && blob_storage_context_) {
-    scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle =
+    scoped_ptr<storage::BlobDataHandle> blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response.blob_uuid);
     if (!blob_data_handle) {
       // The renderer gave us a bad blob UUID.
       DeliverErrorResponse();
       return;
     }
-    blob_request_ = webkit_blob::BlobProtocolHandler::CreateBlobRequest(
+    blob_request_ = storage::BlobProtocolHandler::CreateBlobRequest(
         blob_data_handle.Pass(), request()->context(), this);
     blob_request_->Start();
   }
 
   response_url_ = response.url;
   CreateResponseHeader(
       response.status_code, response.status_text, response.headers);
   if (!blob_request_)
     CommitResponseHeader();
 }
@@ skipping 29 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