Adds class ServiceWorkerScriptCacheMap and new ServiceWorkerVersion::Listener methods related to sc…

content/browser/service_worker/service_worker_version.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_version.h"
 
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
@@ skipping 70 matching lines @@
 }  // namespace
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
     int64 version_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
     : version_id_(version_id),
       registration_id_(kInvalidServiceWorkerVersionId),
       status_(NEW),
       context_(context),
+      script_cache_map_(this),
       weak_factory_(this) {
   DCHECK(context_);
+  DCHECK(registration);
   if (registration) {
     registration_id_ = registration->id();
     script_url_ = registration->script_url();
     scope_ = registration->pattern();
   }
   context_->AddLiveVersion(this);
   embedded_worker_ = context_->embedded_worker_registry()->CreateWorker();
   embedded_worker_->AddListener(this);
 }
 
@@ skipping 241 matching lines @@
 }
 
 void ServiceWorkerVersion::AddListener(Listener* listener) {
   listeners_.AddObserver(listener);
 }
 
 void ServiceWorkerVersion::RemoveListener(Listener* listener) {
   listeners_.RemoveObserver(listener);
 }
 
+void ServiceWorkerVersion::NotifyMainScriptCached(bool success) {
+  FOR_EACH_OBSERVER(Listener, listeners_, OnMainScriptCached(this, success));
+}
+
+void ServiceWorkerVersion::NotifyAllScriptsCached(bool success) {
+  FOR_EACH_OBSERVER(Listener, listeners_, OnAllScriptsCached(this, success));
+}
+
 void ServiceWorkerVersion::OnStarted() {
   DCHECK_EQ(RUNNING, running_status());
   // Fire all start callbacks.
   RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_OK);
   FOR_EACH_OBSERVER(Listener, listeners_, OnWorkerStarted(this));
 }
 
 void ServiceWorkerVersion::OnStopped() {
   DCHECK_EQ(STOPPED, running_status());
   scoped_refptr<ServiceWorkerVersion> protect(this);
@@ skipping 179 matching lines @@
   if (!callback) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(SERVICE_WORKER_OK);
   sync_callbacks_.Remove(request_id);
 }
 
-void ServiceWorkerVersion::AddToScriptCache(
-    const GURL& url, int64 resource_id) {
-  DCHECK_EQ(kInvalidServiceWorkerResponseId, LookupInScriptCache(url));
-  DCHECK_EQ(NEW, status_);
-  script_cache_map_[url] = resource_id;
-}
-
-int64 ServiceWorkerVersion::LookupInScriptCache(const GURL& url) {
-  ResourceIDMap::const_iterator found = script_cache_map_.find(url);
-  if (found == script_cache_map_.end())
-    return kInvalidServiceWorkerResponseId;
-  return found->second;
-}
-
 void ServiceWorkerVersion::OnPostMessageToDocument(
     int client_id,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids) {
   ServiceWorkerProviderHost* provider_host =
       controllee_by_id_.Lookup(client_id);
   if (!provider_host) {
     // The client may already have been closed, just ignore.
     return;
   }
   provider_host->PostMessage(message, sent_message_port_ids);
 }
 
 }  // namespace content