ServiceWorker: Introduce ServiceWorkerDiskCacheMigrator

content/browser/service_worker/service_worker_disk_cache_migrator.cc

Index: content/browser/service_worker/service_worker_disk_cache_migrator.cc
diff --git a/content/browser/service_worker/service_worker_disk_cache_migrator.cc b/content/browser/service_worker/service_worker_disk_cache_migrator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..df67b78003abfc0ea3be3ee0108e20a0478eb8e5
--- /dev/null
+++ b/content/browser/service_worker/service_worker_disk_cache_migrator.cc
@@ -0,0 +1,343 @@
+// Copyright 2015 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_disk_cache_migrator.h"
+
+#include "base/memory/ref_counted.h"
+#include "base/strings/string_number_conversions.h"
+#include "content/common/service_worker/service_worker_types.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/disk_cache/disk_cache.h"
+
+namespace content {
+
+namespace {
+
+// Disk cache entry data indices (Copied from appcache_diskcache.cc).
+enum { kResponseInfoIndex, kResponseContentIndex, kResponseMetadataIndex };
+
+}  // namespace
+
+// A task to move a cached resource from the src DiskCache to the dest
+// DiskCache. This is owned by ServiceWorkerDiskCacheMigrator.
+class ServiceWorkerDiskCacheMigrator::Task {
+ public:
+  Task(InflightTaskMap::KeyType task_id,
+       int64 resource_id,
+       int32 data_size,
+       ServiceWorkerDiskCache* src,
+       ServiceWorkerDiskCache* dest,
+       const base::WeakPtr<ServiceWorkerDiskCacheMigrator>& owner);
+  ~Task();
+
+  void Run();
+
+  InflightTaskMap::KeyType task_id() const { return task_id_; }
+
+ private:
+  void ReadResponseInfo();
+  void OnReadResponseInfo(
+      const scoped_refptr<HttpResponseInfoIOBuffer>& info_buffer,
+      int result);
+  void OnWriteResponseInfo(
+      const scoped_refptr<HttpResponseInfoIOBuffer>& info_buffer,
+      int result);
+  void WriteResponseMetadata(
+      const scoped_refptr<HttpResponseInfoIOBuffer>& info_buffer);
+  void OnWriteResponseMetadata(
+      const scoped_refptr<HttpResponseInfoIOBuffer>& info_buffer,
+      int result);
+  void ReadResponseData();
+  void OnReadResponseData(const scoped_refptr<net::IOBuffer>& buffer,
+                          int result);
+  void OnWriteResponseData(int result);
+  void Finish(ServiceWorkerStatusCode status);
+
+  InflightTaskMap::KeyType task_id_;
+  int64 resource_id_;
+  int32 data_size_;
+  base::WeakPtr<ServiceWorkerDiskCacheMigrator> owner_;
+
+  scoped_ptr<ServiceWorkerResponseReader> reader_;
+  scoped_ptr<ServiceWorkerResponseWriter> writer_;
+  scoped_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer_;
+
+  base::WeakPtrFactory<Task> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(Task);
+};
+
+// A wrapper class for disk_cache::Entry. This is used for holding an open entry
+// and ensuring that the entry gets closed on the dtor.
+class ServiceWorkerDiskCacheMigrator::WrappedEntry {
+ public:
+  WrappedEntry() {}
+
+  ~WrappedEntry() {
+    if (entry_)
+      entry_->Close();
+  }
+
+  disk_cache::Entry* Unwrap() {
+    disk_cache::Entry* entry = entry_;
+    entry_ = nullptr;
+    return entry;
+  }
+
+  disk_cache::Entry** GetPtr() { return &entry_; }
+
+ private:
+  disk_cache::Entry* entry_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(WrappedEntry);
+};
+
+ServiceWorkerDiskCacheMigrator::Task::Task(
+    InflightTaskMap::KeyType task_id,
+    int64 resource_id,
+    int32 data_size,
+    ServiceWorkerDiskCache* src,
+    ServiceWorkerDiskCache* dest,
+    const base::WeakPtr<ServiceWorkerDiskCacheMigrator>& owner)
+    : task_id_(task_id),
+      resource_id_(resource_id),
+      data_size_(data_size),
+      owner_(owner),
+      weak_factory_(this) {
+  DCHECK_LE(0, data_size_);
+  reader_.reset(new ServiceWorkerResponseReader(resource_id, src));
+  writer_.reset(new ServiceWorkerResponseWriter(resource_id, dest));
+  metadata_writer_.reset(
+      new ServiceWorkerResponseMetadataWriter(resource_id, dest));
+}
+
+ServiceWorkerDiskCacheMigrator::Task::~Task() {
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::Run() {
+  ReadResponseInfo();
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::ReadResponseInfo() {
+  scoped_refptr<HttpResponseInfoIOBuffer> info_buffer(
+      new HttpResponseInfoIOBuffer);
+  reader_->ReadInfo(info_buffer.get(),
+                    base::Bind(&Task::OnReadResponseInfo,
+                               weak_factory_.GetWeakPtr(), info_buffer));
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::OnReadResponseInfo(
+    const scoped_refptr<HttpResponseInfoIOBuffer>& info_buffer,
+    int result) {
+  if (result < 0) {
+    LOG(ERROR) << "Failed to read the response info";
+    Finish(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+  writer_->WriteInfo(info_buffer.get(),
+                     base::Bind(&Task::OnWriteResponseInfo,
+                                weak_factory_.GetWeakPtr(), info_buffer));
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::OnWriteResponseInfo(
+    const scoped_refptr<HttpResponseInfoIOBuffer>& buffer,
+    int result) {
+  if (result < 0) {
+    LOG(ERROR) << "Failed to write the response info";
+    Finish(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+
+  const net::HttpResponseInfo* http_info = buffer->http_info.get();
+  if (http_info->metadata && http_info->metadata->size()) {
+    WriteResponseMetadata(buffer);
+    return;
+  }
+  ReadResponseData();
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::WriteResponseMetadata(
+    const scoped_refptr<HttpResponseInfoIOBuffer>& info_buffer) {
+  const net::HttpResponseInfo* http_info = info_buffer->http_info.get();
+  DCHECK(http_info->metadata);
+  DCHECK(http_info->metadata->size());
+
+  // |wrapped_buffer| does not own the given metadata buffer, so a callback
+  // for WriteMetadata keeps |info_buffer| which is the real owner of the
+  // metadata buffer.
+  scoped_refptr<net::WrappedIOBuffer> wrapped_buffer =
+      new net::WrappedIOBuffer(http_info->metadata->data());
+  metadata_writer_->WriteMetadata(
+      wrapped_buffer.get(), http_info->metadata->size(),
+      base::Bind(&Task::OnWriteResponseMetadata, weak_factory_.GetWeakPtr(),
+                 info_buffer));
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::OnWriteResponseMetadata(
+    const scoped_refptr<HttpResponseInfoIOBuffer>& info_buffer,
+    int result) {
+  if (result < 0) {
+    LOG(ERROR) << "Failed to write the response metadata";
+    Finish(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+  DCHECK_EQ(info_buffer->http_info->metadata->size(), result);
+  ReadResponseData();
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::ReadResponseData() {
+  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(data_size_);
+  reader_->ReadData(buffer.get(), data_size_,
+                    base::Bind(&Task::OnReadResponseData,
+                               weak_factory_.GetWeakPtr(), buffer));
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::OnReadResponseData(
+    const scoped_refptr<net::IOBuffer>& buffer,
+    int result) {
+  if (result < 0) {
+    LOG(ERROR) << "Failed to read the response data";
+    Finish(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+  DCHECK_EQ(data_size_, result);
+  writer_->WriteData(
+      buffer.get(), result,
+      base::Bind(&Task::OnWriteResponseData, weak_factory_.GetWeakPtr()));
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::OnWriteResponseData(int result) {
+  if (result < 0) {
+    LOG(ERROR) << "Failed to write the response data";
+    Finish(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+  DCHECK_EQ(data_size_, result);
+  Finish(SERVICE_WORKER_OK);
+}
+
+void ServiceWorkerDiskCacheMigrator::Task::Finish(
+    ServiceWorkerStatusCode status) {
+  DCHECK(owner_);
+  owner_->OnEntryMigrated(task_id_, status);
+}
+
+ServiceWorkerDiskCacheMigrator::ServiceWorkerDiskCacheMigrator(
+    ServiceWorkerDiskCache* src,
+    ServiceWorkerDiskCache* dest)
+    : src_(src), dest_(dest), weak_factory_(this) {
+  DCHECK(!src_->is_disabled());
+  DCHECK(!dest_->is_disabled());
+}
+
+ServiceWorkerDiskCacheMigrator::~ServiceWorkerDiskCacheMigrator() {
+}
+
+void ServiceWorkerDiskCacheMigrator::Start(const StatusCallback& callback) {
+  callback_ = callback;
+  iterator_ = src_->disk_cache()->CreateIterator();
+  OpenNextEntry();
+}
+
+void ServiceWorkerDiskCacheMigrator::OpenNextEntry() {
+  DCHECK(!pending_task_);
+  DCHECK(!is_iterating_);
+  is_iterating_ = true;
+
+  scoped_ptr<WrappedEntry> wrapped_entry(new WrappedEntry);
+  disk_cache::Entry** entry_ptr = wrapped_entry->GetPtr();
+
+  net::CompletionCallback callback = base::Bind(
+      &ServiceWorkerDiskCacheMigrator::OnNextEntryOpened,
+      weak_factory_.GetWeakPtr(), base::Passed(wrapped_entry.Pass()));
+  int result = iterator_->OpenNextEntry(entry_ptr, callback);
+  if (result == net::ERR_IO_PENDING)
+    return;
+  callback.Run(result);
+}
+
+void ServiceWorkerDiskCacheMigrator::OnNextEntryOpened(
+    scoped_ptr<WrappedEntry> wrapped_entry,
+    int result) {
+  DCHECK(!pending_task_);
+  is_iterating_ = false;
+
+  if (result == net::ERR_FAILED) {
+    // ERR_FAILED means the iterator reached the end of the enumeration.
+    if (inflight_tasks_.IsEmpty())
+      Complete(SERVICE_WORKER_OK);
+    return;
+  }
+
+  if (result != net::OK) {
+    LOG(ERROR) << "Failed to open the next entry";
+    inflight_tasks_.Clear();
+    Complete(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+
+  disk_cache::ScopedEntryPtr scoped_entry(wrapped_entry->Unwrap());
+  DCHECK(scoped_entry);
+
+  int64 resource_id = kInvalidServiceWorkerResourceId;
+  if (!base::StringToInt64(scoped_entry->GetKey(), &resource_id)) {
+    LOG(ERROR) << "Failed to read the resource id";
+    inflight_tasks_.Clear();
+    Complete(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+
+  InflightTaskMap::KeyType task_id = next_task_id_++;
+  pending_task_.reset(new Task(task_id, resource_id,
+                               scoped_entry->GetDataSize(kResponseContentIndex),
+                               src_, dest_, weak_factory_.GetWeakPtr()));
+  if (inflight_tasks_.size() < max_number_of_inflight_tasks_) {
+    RunPendingTask();
+    OpenNextEntry();
+    return;
+  }
+  // |pending_task_| will run when an inflight task is completed.
+}
+
+void ServiceWorkerDiskCacheMigrator::RunPendingTask() {
+  DCHECK(pending_task_);
+  DCHECK_GT(max_number_of_inflight_tasks_, inflight_tasks_.size());
+  InflightTaskMap::KeyType task_id = pending_task_->task_id();
+  pending_task_->Run();
+  inflight_tasks_.AddWithID(pending_task_.release(), task_id);
+}
+
+void ServiceWorkerDiskCacheMigrator::OnEntryMigrated(
+    InflightTaskMap::KeyType task_id,
+    ServiceWorkerStatusCode status) {
+  DCHECK(inflight_tasks_.Lookup(task_id));
+  inflight_tasks_.Remove(task_id);
+
+  if (status != SERVICE_WORKER_OK) {
+    inflight_tasks_.Clear();
+    Complete(status);
+    return;
+  }
+
+  if (pending_task_) {
+    RunPendingTask();
+    OpenNextEntry();
+    return;
+  }
+
+  if (is_iterating_)
+    return;
+
+  if (inflight_tasks_.IsEmpty())
+    Complete(SERVICE_WORKER_OK);
+}
+
+void ServiceWorkerDiskCacheMigrator::Complete(ServiceWorkerStatusCode status) {
+  DCHECK(inflight_tasks_.IsEmpty());
+  // TODO(nhiroki): Add UMA for the result of migration.
+  callback_.Run(status);
+}
+
+}  // namespace content