Stitch CacheStorage messages to implementation.

content/browser/service_worker/service_worker_context_core.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 44 matching lines @@
  public:
   typedef base::Callback<void(ServiceWorkerStatusCode status)> StatusCallback;
   typedef base::Callback<void(ServiceWorkerStatusCode status,
                               int64 registration_id,
                               int64 version_id)> RegistrationCallback;
   typedef base::Callback<
       void(ServiceWorkerStatusCode status)> UnregistrationCallback;
   typedef IDMap<ServiceWorkerProviderHost, IDMapOwnPointer> ProviderMap;
   typedef IDMap<ProviderMap, IDMapOwnPointer> ProcessToProviderMap;
 
-  // Directory for ServiceWorkerStorage and ServiceWorkerFetchStores.
+  // Directory for ServiceWorkerStorage and ServiceWorkerCacheManager.
   static const base::FilePath::CharType kServiceWorkerDirectory[];
 
   // Iterates over ServiceWorkerProviderHost objects in a ProcessToProviderMap.
   class ProviderHostIterator {
    public:
     ~ProviderHostIterator();
     ServiceWorkerProviderHost* GetProviderHost();
     void Advance();
     bool IsAtEnd();
 
@@ skipping 10 matching lines @@
   };
 
   // This is owned by the StoragePartition, which will supply it with
   // the local path on disk. Given an empty |user_data_directory|,
   // nothing will be stored on disk. |observer_list| is created in
   // ServiceWorkerContextWrapper. When Notify() of |observer_list| is called in
   // ServiceWorkerContextCore, the methods of ServiceWorkerContextObserver will
   // be called on the thread which called AddObserver() of |observer_list|.
   ServiceWorkerContextCore(
       const base::FilePath& user_data_directory,
-      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);
   ServiceWorkerContextCore(
       ServiceWorkerContextCore* old_context,
       ServiceWorkerContextWrapper* wrapper);
   virtual ~ServiceWorkerContextCore();
 
   // ServiceWorkerVersion::Listener overrides.
   virtual void OnWorkerStarted(ServiceWorkerVersion* version) OVERRIDE;
   virtual void OnWorkerStopped(ServiceWorkerVersion* version) OVERRIDE;
   virtual void OnVersionStateChanged(ServiceWorkerVersion* version) OVERRIDE;
   virtual void OnErrorReported(ServiceWorkerVersion* version,
                                const base::string16& error_message,
                                int line_number,
                                int column_number,
                                const GURL& source_url) OVERRIDE;
   virtual void OnReportConsoleMessage(ServiceWorkerVersion* version,
                                       int source_identifier,
                                       int message_level,
                                       const base::string16& message,
                                       int line_number,
                                       const GURL& source_url) OVERRIDE;
 
   ServiceWorkerStorage* storage() { return storage_.get(); }
-  ServiceWorkerCacheStorageManager* fetch_stores_manager() {
-    return fetch_stores_manager_.get();
+  ServiceWorkerCacheStorageManager* cache_manager() {
+    return cache_manager_.get();
   }
   ServiceWorkerProcessManager* process_manager();
   EmbeddedWorkerRegistry* embedded_worker_registry() {
     return embedded_worker_registry_.get();
   }
   ServiceWorkerJobCoordinator* job_coordinator() {
     return job_coordinator_.get();
   }
 
   // The context class owns the set of ProviderHosts.
@@ skipping 59 matching lines @@
                               const UnregistrationCallback& callback,
                               ServiceWorkerStatusCode status);
 
   base::WeakPtrFactory<ServiceWorkerContextCore> weak_factory_;
   // It's safe to store a raw pointer instead of a scoped_refptr to |wrapper_|
   // because the Wrapper::Shutdown call that hops threads to destroy |this| uses
   // Bind() to hold a reference to |wrapper_| until |this| is fully destroyed.
   ServiceWorkerContextWrapper* wrapper_;
   scoped_ptr<ProcessToProviderMap> providers_;
   scoped_ptr<ServiceWorkerStorage> storage_;
-  scoped_ptr<ServiceWorkerCacheStorageManager> fetch_stores_manager_;
+  scoped_ptr<ServiceWorkerCacheStorageManager> cache_manager_;
   scoped_refptr<EmbeddedWorkerRegistry> embedded_worker_registry_;
   scoped_ptr<ServiceWorkerJobCoordinator> job_coordinator_;
   std::map<int64, ServiceWorkerRegistration*> live_registrations_;
   std::map<int64, ServiceWorkerVersion*> live_versions_;
   int next_handle_id_;
   scoped_refptr<ObserverListThreadSafe<ServiceWorkerContextObserver> >
       observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContextCore);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_