CacheStorage: Implement Cache.matchAll()

content/browser/cache_storage/cache_storage_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/cache_storage/cache_storage_cache.h"
 
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
+#include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_blob_to_disk_cache.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/referrer.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
@@ skipping 149 matching lines @@
   if (!metadata->ParseFromArray(buffer->data(), buffer->size())) {
     callback.Run(scoped_ptr<CacheMetadata>());
     return;
   }
 
   callback.Run(metadata.Pass());
 }
 
 }  // namespace
 
+// The state needed to pass between CacheStorageCache::MatchAll callbacks.
+struct CacheStorageCache::MatchAllContext {
+  explicit MatchAllContext(const CacheStorageCache::ResponsesCallback& callback)
+      : original_callback(callback), enumerated_entry(nullptr) {}
+
+  ~MatchAllContext() {
+    for (disk_cache::Entry* entry_ptr : entries)
+      entry_ptr->Close();
+    if (enumerated_entry)
+      enumerated_entry->Close();
+  }
+
+  // The callback passed to the MatchAll() function.
+  CacheStorageCache::ResponsesCallback original_callback;
+
+  // The list of open entries in the backend.
+  std::list<disk_cache::Entry*> entries;
+
+  // The outputs of the MatchAll function.
+  std::vector<ServiceWorkerResponse> out_responses;
+  ScopedVector<storage::BlobDataHandle> out_blob_data_handles;
+
+  // Used for enumerating cache entries.
+  scoped_ptr<disk_cache::Backend::Iterator> backend_iterator;
+  disk_cache::Entry* enumerated_entry;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MatchAllContext);
+};
+
 // The state needed to pass between CacheStorageCache::Keys callbacks.
 struct CacheStorageCache::KeysContext {
   explicit KeysContext(const CacheStorageCache::RequestsCallback& callback)
       : original_callback(callback),
         out_keys(new CacheStorageCache::Requests()),
         enumerated_entry(NULL) {}
 
   ~KeysContext() {
     for (size_t i = 0, max = entries.size(); i < max; ++i)
       entries[i]->Close();
@@ skipping 89 matching lines @@
   }
 
   ResponseCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(request.Pass()), pending_callback));
 }
 
+void CacheStorageCache::MatchAll(const ResponsesCallback& callback) {
+  if (!LazyInitialize()) {
+    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
+                 std::vector<ServiceWorkerResponse>(),
+                 ScopedVector<storage::BlobDataHandle>());
+    return;
+  }
+
+  ResponsesCallback pending_callback =
+      base::Bind(&CacheStorageCache::PendingResponsesCallback,
+                 weak_ptr_factory_.GetWeakPtr(), callback);
+  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::MatchAllImpl,
+                                           weak_ptr_factory_.GetWeakPtr(),
+                                           pending_callback));
+}
+
 void CacheStorageCache::BatchOperation(
     const std::vector<CacheStorageBatchOperation>& operations,
     const ErrorCallback& callback) {
   if (!LazyInitialize()) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   scoped_ptr<ErrorCallback> callback_copy(new ErrorCallback(callback));
   ErrorCallback* callback_ptr = callback_copy.get();
@@ skipping 242 matching lines @@
 
   disk_cache::Entry* temp_entry = entry.get();
   blob_data.AppendDiskCacheEntry(
       new CacheStorageCacheDataHandle(this, entry.Pass()), temp_entry,
       INDEX_RESPONSE_BODY);
   scoped_ptr<storage::BlobDataHandle> blob_data_handle(
       blob_storage_context_->AddFinishedBlob(&blob_data));
   callback.Run(CACHE_STORAGE_OK, response.Pass(), blob_data_handle.Pass());
 }
 
+void CacheStorageCache::MatchAllImpl(const ResponsesCallback& callback) {
+  DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
+  if (backend_state_ != BACKEND_OPEN) {
+    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
+                 std::vector<ServiceWorkerResponse>(),
+                 ScopedVector<storage::BlobDataHandle>());
+    return;
+  }
+
+  scoped_ptr<MatchAllContext> context(new MatchAllContext(callback));
+
+  context->backend_iterator = backend_->CreateIterator();
+  disk_cache::Backend::Iterator& iterator = *context->backend_iterator;
+  disk_cache::Entry** enumerated_entry = &context->enumerated_entry;
+
+  net::CompletionCallback open_entry_callback =
+      base::Bind(&CacheStorageCache::MatchAllDidOpenNextEntry,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(context.Pass()));
+
+  int rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
+
+  if (rv != net::ERR_IO_PENDING)
+    open_entry_callback.Run(rv);
+}
+
+void CacheStorageCache::MatchAllDidOpenNextEntry(

[jkarlin, 2015/08/04 13:25:07]

This method should go, instead make a common utility function that MatchAll and
Keys can share to open all of the entries in a vector or list.

[nhiroki, 2015/08/05 08:03:04]

Done.

+    scoped_ptr<MatchAllContext> context,
+    int rv) {
+  if (rv == net::ERR_FAILED) {
+    DCHECK(!context->enumerated_entry);
+    // Enumeration is complete, extract the requests from the entries.
+    MatchAllProcessNextEntry(context.Pass());
+    return;
+  }
+
+  if (rv < 0) {
+    context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
+                                   std::vector<ServiceWorkerResponse>(),
+                                   ScopedVector<storage::BlobDataHandle>());
+    return;
+  }
+
+  if (backend_state_ != BACKEND_OPEN) {
+    context->original_callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
+                                   std::vector<ServiceWorkerResponse>(),
+                                   ScopedVector<storage::BlobDataHandle>());
+    return;
+  }
+
+  // Store the entry.
+  context->entries.push_back(context->enumerated_entry);
+  context->enumerated_entry = nullptr;
+
+  // Enumerate the next entry.
+  disk_cache::Backend::Iterator& iterator = *context->backend_iterator;
+  disk_cache::Entry** enumerated_entry = &context->enumerated_entry;
+  net::CompletionCallback open_entry_callback =
+      base::Bind(&CacheStorageCache::MatchAllDidOpenNextEntry,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(context.Pass()));
+
+  rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
+
+  if (rv != net::ERR_IO_PENDING)
+    open_entry_callback.Run(rv);
+}
+
+void CacheStorageCache::MatchAllProcessNextEntry(
+    scoped_ptr<MatchAllContext> context) {
+  if (context->entries.empty()) {
+    // All done. Return all of the responses.
+    context->original_callback.Run(CACHE_STORAGE_OK, context->out_responses,
+                                   context->out_blob_data_handles.Pass());
+    return;
+  }
+
+  disk_cache::ScopedEntryPtr entry(context->entries.front());
+  context->entries.pop_front();
+  disk_cache::Entry* entry_ptr = entry.get();
+  ReadMetadata(
+      entry_ptr,
+      base::Bind(&CacheStorageCache::MatchAllDidReadMetadata,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(context.Pass()),
+                 base::Passed(entry.Pass())));
+}
+
+void CacheStorageCache::MatchAllDidReadMetadata(
+    scoped_ptr<MatchAllContext> context,
+    disk_cache::ScopedEntryPtr entry,
+    scoped_ptr<CacheMetadata> metadata) {
+  if (!metadata) {
+    entry->Doom();
+    MatchAllProcessNextEntry(context.Pass());
+    return;
+  }
+
+  ServiceWorkerResponse response(

[jkarlin, 2015/08/04 13:25:07]

The code below should be combined with MatchDidReadMetadata somehow. No need for
the duplication.

[nhiroki, 2015/08/05 08:03:04]

Done.

+      GURL(metadata->response().url()), metadata->response().status_code(),
+      metadata->response().status_text(),
+      ProtoResponseTypeToWebResponseType(metadata->response().response_type()),
+      ServiceWorkerHeaderMap(), "", 0, GURL(),
+      blink::WebServiceWorkerResponseErrorUnknown);
+
+  for (int i = 0; i < metadata->response().headers_size(); ++i) {
+    const CacheHeaderMap header = metadata->response().headers(i);
+    DCHECK_EQ(std::string::npos, header.name().find('\0'));
+    DCHECK_EQ(std::string::npos, header.value().find('\0'));
+    response.headers.insert(std::make_pair(header.name(), header.value()));
+  }
+
+  ServiceWorkerHeaderMap cached_request_headers;
+  for (int i = 0; i < metadata->request().headers_size(); ++i) {
+    const CacheHeaderMap header = metadata->request().headers(i);
+    DCHECK_EQ(std::string::npos, header.name().find('\0'));
+    DCHECK_EQ(std::string::npos, header.value().find('\0'));
+    cached_request_headers[header.name()] = header.value();
+  }
+
+  if (entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
+    context->out_responses.push_back(response);
+    context->out_blob_data_handles.push_back(nullptr);
+    MatchAllProcessNextEntry(context.Pass());
+    return;
+  }
+
+  if (!blob_storage_context_) {
+    entry->Doom();
+    MatchAllProcessNextEntry(context.Pass());
+    return;
+  }
+
+  // Create a blob with the response body data.
+  response.blob_size = entry->GetDataSize(INDEX_RESPONSE_BODY);
+  response.blob_uuid = base::GenerateGUID();
+  storage::BlobDataBuilder blob_data(response.blob_uuid);
+
+  disk_cache::Entry* entry_ptr = entry.get();
+  blob_data.AppendDiskCacheEntry(
+      new CacheStorageCacheDataHandle(this, entry.Pass()), entry_ptr,
+      INDEX_RESPONSE_BODY);
+  scoped_ptr<storage::BlobDataHandle> blob_data_handle(
+      blob_storage_context_->AddFinishedBlob(&blob_data));
+
+  context->out_responses.push_back(response);
+  context->out_blob_data_handles.push_back(blob_data_handle.release());
+  MatchAllProcessNextEntry(context.Pass());
+}
+
 void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
                             const ErrorCallback& callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT, operation.operation_type);
 
   scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
       operation.request.url, operation.request.method,
       operation.request.headers, operation.request.referrer,
       operation.request.is_reload));
 
@@ skipping 494 matching lines @@
     CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error, response.Pass(), blob_data_handle.Pass());
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
+void CacheStorageCache::PendingResponsesCallback(
+    const ResponsesCallback& callback,
+    CacheStorageError error,
+    const std::vector<ServiceWorkerResponse>& responses,
+    ScopedVector<storage::BlobDataHandle> blob_data_handles) {
+  base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
+
+  callback.Run(error, responses, blob_data_handles.Pass());
+  if (cache)
+    scheduler_->CompleteOperationAndRunNext();
+}
+
 void CacheStorageCache::PendingRequestsCallback(
     const RequestsCallback& callback,
     CacheStorageError error,
     scoped_ptr<Requests> requests) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error, requests.Pass());
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content