Stitch CacheStorage messages to implementation.

content/browser/service_worker/service_worker_context_core.cc

 // Copyright 2013 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_context_core.h"
 
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
@@ skipping 65 matching lines @@
     ProviderMap* provider_map = process_iterator_->GetCurrentValue();
     provider_host_iterator_.reset(new ProviderMap::iterator(provider_map));
     if (!provider_host_iterator_->IsAtEnd())
       return;
     process_iterator_->Advance();
   }
 }
 
 ServiceWorkerContextCore::ServiceWorkerContextCore(
     const base::FilePath& path,
-    base::SequencedTaskRunner* stores_task_runner,
+    base::SequencedTaskRunner* cache_task_runner,
     base::SequencedTaskRunner* database_task_runner,
     base::MessageLoopProxy* disk_cache_thread,
     quota::QuotaManagerProxy* quota_manager_proxy,
     ObserverListThreadSafe<ServiceWorkerContextObserver>* observer_list,
     ServiceWorkerContextWrapper* wrapper)
     : weak_factory_(this),
       wrapper_(wrapper),
       providers_(new ProcessToProviderMap),
       storage_(ServiceWorkerStorage::Create(path,
                                             AsWeakPtr(),
                                             database_task_runner,
                                             disk_cache_thread,
                                             quota_manager_proxy)),
-      fetch_stores_manager_(
-          ServiceWorkerCacheStorageManager::Create(path, stores_task_runner)),
+      cache_manager_(
+          ServiceWorkerCacheStorageManager::Create(path, cache_task_runner)),
       embedded_worker_registry_(EmbeddedWorkerRegistry::Create(AsWeakPtr())),
       job_coordinator_(new ServiceWorkerJobCoordinator(AsWeakPtr())),
       next_handle_id_(0),
       observer_list_(observer_list) {
 }
 
 ServiceWorkerContextCore::ServiceWorkerContextCore(
     ServiceWorkerContextCore* old_context,
     ServiceWorkerContextWrapper* wrapper)
     : weak_factory_(this),
       wrapper_(wrapper),
       providers_(old_context->providers_.release()),
       storage_(
           ServiceWorkerStorage::Create(AsWeakPtr(), old_context->storage())),
-      fetch_stores_manager_(ServiceWorkerCacheStorageManager::Create(
-          old_context->fetch_stores_manager())),
+      cache_manager_(ServiceWorkerCacheStorageManager::Create(
+          old_context->cache_manager())),
       embedded_worker_registry_(EmbeddedWorkerRegistry::Create(
           AsWeakPtr(),
           old_context->embedded_worker_registry())),
       job_coordinator_(new ServiceWorkerJobCoordinator(AsWeakPtr())),
       next_handle_id_(0),
       observer_list_(old_context->observer_list_) {
 }
 
 ServiceWorkerContextCore::~ServiceWorkerContextCore() {
   for (VersionMap::iterator it = live_versions_.begin();
@@ skipping 261 matching lines @@
       version->embedded_worker()->thread_id(),
       ServiceWorkerContextObserver::ConsoleMessage(
           source_identifier, message_level, message, line_number, source_url));
 }
 
 ServiceWorkerProcessManager* ServiceWorkerContextCore::process_manager() {
   return wrapper_->process_manager();
 }
 
 }  // namespace content